DEV Community: Raunak Kathuria

The AI model is a commodity. Taste isn't.

Raunak Kathuria — Mon, 06 Apr 2026 13:43:10 +0000

When everyone has access to the same AI, your edge is the judgment behind the output.

The first comment on my Reddit post wasn't a question.

I don't think I've ever seen so many stupid ideas and em-dashes in such a short amount of text.

No counter-argument. No nuance. Just a precise observation about punctuation I couldn't shake, because they were right. Not about em-dashes, but about the generic text that was presented.

The post had been written with AI assistance. I'd used em-dashes in almost every sentence, in a rhythm that wasn't mine. The Reddit commenter knew something was off. That's the thing about taste — you recognise the absence of it before you can name it.

Everyone has the same AI

Here's the uncomfortable truth: the model is no longer the differentiator.

Give ten capable people a reasonable prompt and you'll get ten tidy versions of the same answer. Same sentence balance. Same transitions. Same polished neutrality.

The AI optimises for readability, and readable turns out to mean forgettable.

What nobody's discussing: AI was trained to be useful to everyone. That means it has no taste. It has capability without judgment, fluency without instinct. It can write anything, which means it sounds like nothing in particular.

Taste is judgment you can teach

Everyone who's spent years thinking about something develops a taste for it. Not just preferences: a finely tuned sense of what belongs and what doesn't. What to say. What to leave out. What sounds true and what sounds performed.

That taste isn't in the model. It's in you.

Taste is the personalisation you bring to AI — the part that can't be trained on someone else's data.

A doctor has it in diagnosis, the pattern recognition from thousands of cases that flags something wrong before the tests confirm it. A great editor has it for sentences, whether a line is doing the work it thinks it's doing.

AI can generate the words. It can't generate the judgment behind them.

The question is whether you can give it yours.

What I built to do exactly that

After the Reddit comment, I didn't just edit the post. I tried to fix the root cause.

The problem wasn't the output. It was that I'd given the AI no real constraint to work with. Write like me is not a constraint. It's a wish. The AI interpreted it as: write clearly, write professionally, write in a way that nobody will object to. And nobody would object to it, because it had no point of view.

So I spent a few sessions trying to articulate what my voice actually was. Not in general terms, specific ones.

I asked the agent to read through my Substack posts, my LinkedIn writing, our conversation history. Identify the patterns. Push back on what it got wrong. Refine until the description felt accurate enough to be useful.

The output was a file I called TASTE.md.

It's not a style guide. Style guides tell you how to format things. This was closer to a brief for what kind of mind should be speaking: what it cares about, what it would never say, the things that would sound wrong even if they were technically correct.

The difference in the writing was immediate. Not perfect — it took several passes and a proper audit loop to get the AI detection score from 78% down to 11%. The first draft with TASTE.md loaded still scored 62%. Three rounds to get it to 11%. But the direction was right from the start.

Why this matters beyond writing

Writing is just the most visible place where taste shows up.

In code review, the taste is your sense of what good architecture feels like in your specific system, not in the benchmark, not in general, in yours. In product decisions, it's the feel for which trade-off your team can absorb right now and which one will cost you a quarter.

These aren't prompting techniques. They're the accumulated judgment you've built over years, finally expressible in a form something else can use.

The teams that get the most out of AI aren't the ones with the best prompts. They're the ones who've spent time writing it down, something like TASTE.md, but for their domain, specifically enough that they can give it to something that has no beliefs of its own.

The inversion worth sitting with

AI is trained to be a generalist. That framing is holding people back.

The same model with your specific taste, the things that would sound wrong to you even if they're technically correct, produces something different from the same model without it. Each piece builds on the last. The output starts to sound like it came from someone.

And the part I didn't expect: building TASTE.md didn't just make the AI more useful. It made me clearer about what I actually believe. You can't articulate your taste to something else without first understanding it yourself.

The Reddit comment that stung on a Sunday evening was useful. Not because it was about the em-dashes, they were right about the generic text that was presented.

Everyone has access to the same AI. What differentiates you is what you bring to it.

How clearly have you articulated your taste?

This is part one of a two-part series. Part two covers the exact process: how to build your own TASTE.md, the audit loop I use, and what the before/after looks like.

Originally published at raunakkathuria.substack.com

The Agentic Stack

Raunak Kathuria — Mon, 30 Mar 2026 05:16:30 +0000

We’ve spent years building software the same way. A service receives a request, calls another service, writes to a database. Something reads it back. You scale the slow parts, monitor the breaking ones.

That model still works. It’s reliable, well-understood, and well-tooled. But something’s shifted — and if you haven’t felt it yet in your architecture decisions, you will soon.

AI has introduced a new execution layer. Not infrastructure. Not middleware. Something that does work — the kind that used to require a human to sit down, think, and grind through.

The question nobody’s asking right now

Most leaders ask: “Should we use AI?” That’s the wrong level. Everyone’s already using it — in their IDE, their code review tool, their incident runbook.

Ask instead: What’s the architecture?

Because when AI stops being a feature and starts being an execution layer — something that does work rather than assists with work — your system’s structure changes. How you define capability changes. How intent enters the system changes. That’s what the agentic stack is about, and it’s worth understanding before your team figures it out without you.

Three layers. You already know all of them

Claw is the new unit of architecture. A bounded execution unit with its own role, context, tools, and constraints. Not a microservice — it doesn’t expose an API endpoint. It checks Slack, reads files, calls APIs, drafts responses, takes action. It does things.

Skill is the instruction layer. Reusable logic that tells a claw what to do, how to do it, what rules it’s operating under, and what good output looks like. If a claw is the executor, the skill is the judgment baked in.

Prompt is how intent enters the system. Not a rigid API contract — a natural language instruction that activates claws and routes work through skills.

Three layers. Each one maps to something familiar.

Claw is the architecture. Skill is the language. Prompt is the protocol. That’s the stack your team is building on — whether you’ve named it yet or not.

What this replaces and what it doesn't

Here’s where most explanations go sideways: they frame this as replacement. It isn’t, and treating it that way will cause you to either over-invest or dismiss it entirely.

Services still define how systems run. Databases still store state. APIs still integrate third-party tools. None of that changes.

What changes is the coordination layer on top, the work that used to live in Notion docs, Jira comments, and Slack threads.

The glue work. The “someone needs to look at this and decide work”. Before the agentic stack, that required a human. After, a claw handles it.

Meet Priya

She’s a Senior Engineering Manager at a scaling platform team. Her week, pre-agentic stack: 15 PRs moving through review, senior engineers burning two to three hours a day reading diffs, junior engineers waiting three to five days for feedback that came back cryptic half the time anyway.

The process ran like this:

PR opened → Priya manually assigns reviewer based on who knows the area
Reviewer reads 300–500 lines of code
Leaves comments → author reads them, guesses at intent → revises
Reviewer re-reads, re-approves or re-requests changes
Repeat until it's good enough

That's six to eight human touchpoints per PR. Multiply by 15 PRs a week.

They tried building a claw to do first-pass reviews. The skill encoded the team’s standards — naming conventions, test coverage thresholds, security anti-patterns, documentation expectations. First two weeks were rough. It flagged too aggressively, left feedback in a tone that annoyed the engineers, and missed context on a few architectural decisions it didn’t have visibility into.

They fixed the skill. Rewrote the tone guidelines, added the architecture docs to its context, tuned the flagging thresholds. By week four, it was doing what a good junior reviewer would do — and Priya’s seniors were only seeing the PRs that genuinely needed a human call.

That’s the actual story. It wasn’t clean. It worked anyway.

What it looks like in practice

Here's a simplified skill definition for a code review claw:

name: code-review
role: Review pull requests against team engineering standards. Flag violations. Approve clean PRs. Escalate anything touching auth or payments.
context:
  - repo: standards/engineering-guidelines.md
  - file: .github/CODEOWNERS
tools:
  - read_pr_diff
  - post_review_comment
  - request_human_review
  - approve_pr
constraints:
  - Never approve PRs touching /src/auth without human sign-off
  - Always flag missing tests as blocking
  - Post feedback in plain English, not just line references
output:
  - structured review with verdict: approve | changes_requested | escalate
The skill is the logic. The claw is the executor. The PR opening is the prompt.

No new service to build. No new API to maintain. You're composing behaviour, not writing code.

What actually changes for you

Your senior engineers stop being the default reviewers. Their judgment gets encoded into skills — and applied at scale, consistently, without their calendar getting eaten. They shift from doing reviews to defining what a good review looks like. That’s a leverage upgrade.

Code standards become executable, not aspirational. There’s a meaningful difference between a policy nobody reads and a skill a claw runs on every PR. One is stated. One is applied. You’ve probably written a lot of policies that belong in the second category.

Your junior engineers get faster feedback loops. They learn faster because the signal isn’t filtered through whoever had time to review that week.

And you get visibility into work that was previously invisible. Every claw action is logged. Every decision is traceable. Which is a kind of accountability your process almost certainly doesn’t have right now.

How to start

Pick one workflow that is a bottleneck. Not a hypothetical one, a specific named workflow that your team complains about in retros.

Write down, in plain language, what a good human does in that workflow. Step by step. Including the judgment calls, the rules they apply, the things they'd escalate. That's your first skill. The trigger is your first prompt. The claw executes it.

Run it alongside your human process for two weeks. Don’t replace anything yet — just compare the outputs. Trust the parts that are right. Fix the parts that aren’t.

That’s it. Everything else is refinement.

The most interesting thing about this stack isn’t the technology. It’s that the judgment your best people carry around in their heads — the stuff that makes them irreplaceable — can now be encoded and applied everywhere, all the time, without them being in the room.
That’s what’s actually happening. The naming is new. The leverage isn’t.

What workflow in your team still requires a human because nobody’s written down what good looks like? Genuinely curious — drop it in the comments.