---
title: "Discussion on \"Code Is Cheap. Authority Isn't.\" | Hashnode"
description: "Discussion on \"Code Is Cheap. Authority Isn't.\". Agentic AI makes code cheap but authority and verification scarce. A framework for redesigning the SDLC and engineering org around autonomous agents."
url: "https://hashnode.com/posts/code-is-cheap-authority-isn-t/6ad54358d75f37b1b40b3b8d"
---

[Feed](https://hashnode.com/feed) /

Discussion

# [Code Is Cheap. Authority Isn't.](https://arunima-chaudhuri.hashnode.dev/code-is-cheap-authority-isn-t?utm_source=hashnode&utm_medium=feed)

Agentic AI makes code cheap but authority and verification scarce. A framework for redesigning the SDLC and engineering org around autonomous agents.

Oct 18 · 18 min read · arunima-chaudhuri.hashnode.dev  
Read the article

-   [#ai-agents](https://hashnode.com/tag/ai-agents)
-   [#software-engineering](https://hashnode.com/tag/software-engineering)
-   [#devops](https://hashnode.com/tag/devops)
-   [#engineering-management](https://hashnode.com/tag/engineering-management)

## Written by

[Arunima Chaudhuri](https://hashnode.com/@ArunimaChaudhuri)

@ArunimaChaudhuri · Kolkata, India

  
[View profile](https://hashnode.com/@ArunimaChaudhuri)

Research Engineer @ Status | Ex - Intern @Status @Hyperledger @Solana Labs | M.Tech CSE ’25 @NITW

Research Engineer @ Status | Ex - Intern @Status @Hyperledger @Solana Labs | M.Tech CSE ’25 @NITW

## Responses 4

Markdown supported · ⌘↵ to post

[Oct 19](https://hashnode.com/posts/code-is-cheap-authority-isn-t/6ad54358d75f37b1b40b3b8d/comment/6ad5818839cde4bbff59bf86)

The shift you describe, from writing code to granting authority, matches what I see in client work. Code got cheap, but someone still has to say what the system is allowed to do and who answers for it when it does the wrong thing.

Abhinav's question in the replies is the right one: if evidence is the scarce resource, the agent should not also write the rubric. One answer is to fix the acceptance criteria before the work starts and keep them out of the agent's reach. The human writes what done means, the agent produces evidence against it, and review becomes a comparison rather than a reading of whatever the agent chose to show.

That also makes authority easier to grant in small pieces: one clearly scoped task, one written finish line, one person accountable for the sign-off. Who owns the acceptance criteria when the system of agents spans several teams?

[Arunima Chaudhuri](https://hashnode.com/@ArunimaChaudhuri)

[Nov 3](https://hashnode.com/posts/code-is-cheap-authority-isn-t/6ad54358d75f37b1b40b3b8d/comment/6ad5818839cde4bbff59bf86#reply-6ae98768efde647f3203fd37)

Thanks, this is a sharper version of the point than mine. “Review becomes a comparison rather than a reading” is the shift I was trying to describe.

On your question, my answer is that criteria should be owned at the boundary where an outcome becomes visible, not wherever the agents happen to run. Each team owns acceptance criteria for its own domain. The interfaces between teams get their own contract, owned by whoever consumes it, because they’re the ones who get hurt when it breaks. Invariants that span the whole system (data ownership, tenancy, money) need one named owner, usually a tech lead or platform function.

The failure mode I’d watch for is ownership by committee. If three teams “jointly own” the criteria for a cross-team flow, nobody does, and the agents fill that gap with whatever they infer. One name per contract, even when the system spans ten teams.

[Abhinav Sharma](https://hashnode.com/@abhinavs1920)

[Oct 19](https://hashnode.com/posts/code-is-cheap-authority-isn-t/6ad54358d75f37b1b40b3b8d/comment/6ad56d2839cde4bbff5982c3)

Review time up 91% while PRs got 154% larger means review is the thing that gives, and once merged-with-no-review becomes normal it stops looking like a decision anyone made. The piece I'd push on: if evidence is the scarce resource, what stops the agent from generating the evidence too? Then the human is grading work against a rubric the worker wrote.

[Arunima Chaudhuri](https://hashnode.com/@ArunimaChaudhuri)

[Nov 3](https://hashnode.com/posts/code-is-cheap-authority-isn-t/6ad54358d75f37b1b40b3b8d/comment/6ad56d2839cde4bbff5982c3#reply-6ae9877eb09e0c496f5ea55e)

You’re right that once merged-with-no-review becomes normal, it stops looking like a decision. That’s why I’d track the unreviewed-merge rate explicitly. It turns a silent default back into a number someone has to answer for.

On your question, I’d separate evidence from the rubric. Agents can and should generate evidence, because that’s the cheap part. What they can’t be allowed to do is define what counts as passing. In practice that means three things:

1.  A human writes the acceptance criteria before the work starts, and they sit somewhere the building agent can’t edit.
2.  The verifier runs in a different session from the builder, with different context.
3.  You check the tests themselves, for example with mutation testing: if you deliberately break the code and the tests still pass, the evidence is theatre.

The risk you’re describing is real when one agent writes the code, the tests and the definition of done. Split those three apart and the human is grading against their own rubric again.
