Agent-Native Is Not About Writing Code
For the past year, every conversation about AI writing code has been chasing the wrong problem.
The real question was never how much code an Agent can write.
Code Is Becoming the Cheapest Thing
Code generation is a commodity. Copilot, Cursor, Claude Code — the capabilities are converging. The gaps are shrinking.
Software engineering is shifting from code scarcity to context scarcity.
An Agent can generate thousands of lines in minutes. But it doesn’t know:
- Why this feature exists
- Which business rule cannot be broken
- Which dependency is off-limits
- What test result actually proves the change is safe
None of that knowledge lives in the code. It lives in design discussions, postmortems, historical decisions, and the heads of your senior engineers.
Code will be the cheapest thing. Correct context will be the most expensive.
Agent-Native Isn’t About Coding
Most people define Agent-Native Development as “letting Agents complete development tasks autonomously.”
That’s too shallow.
Agents were never bottlenecked on coding ability. They’re bottlenecked on understanding and verification.
Think about what a seasoned engineer actually spends time on. It’s not writing code. It’s understanding requirements, clarifying scope, analyzing impact, validating design assumptions, assessing risk, proving outcomes are correct.
That’s all knowledge work.
So the core question for Agent-Native isn’t:
How do we make agents generate code?
It’s:
How do we make organizational knowledge consumable and verifiable?
The Repository Is Only Part of the Truth
Teams are starting to maintain AGENTS.md, CONTEXT.md, OpenSpecs, repo-level documentation.
Good practices. They’re making implicit knowledge explicit.
But there’s a fundamental misconception buried in this trend:
The repository is not the source of truth.
The codebase captures one slice of system knowledge. The rest lives elsewhere: Datadog metrics, Grafana dashboards, feature flag configs, AWS state, incident history, Architecture Decision Records.
Why a service was designed a certain way often matters more than the code itself.
That answer probably isn’t in the repo.
Repository is part of the truth, not the truth.
The Hard Part of Knowledge Systems Isn’t Capturing — It’s Maintaining
Nearly every knowledge management system in history has failed. Wikis, Confluence, SharePoint, design docs — all of them.
The reason isn’t complicated. People write. Nobody maintains.
When maintenance cost exceeds the benefit, knowledge goes stale fast. Teams stop trusting docs. They trust only the code. The knowledge system dies.
Documentation as Responsibility almost always fails.
Depending on engineers to proactively maintain docs is a losing bet. This isn’t an attitude problem. It’s an incentive structure problem.
A Better Model: Agents Maintain Knowledge, Not Just Consume It
The default pattern today is:
1
Human writes context → Agent reads context
Still human-driven.
A more sustainable model:
1
Human owns truth → Agent maintains truth
After a code change, the Agent automatically updates the OpenSpec, README, API docs, deployment notes. Engineers review and approve — they don’t write from scratch.
Documentation should be a byproduct of development, not a separate activity.
Only when maintaining knowledge becomes cheap enough will knowledge systems actually survive.
What’s Really Changing Is Knowledge Management
Everyone expects AI to change how we write code.
AI is more likely to change how we manage knowledge.
Old model: engineers store understanding in their heads, then encode it as code.
New model: humans and Agents co-build organizational knowledge together — knowledge that serves both people and machines.
Knowledge stops belonging to a person. It stops belonging to a document.
It belongs to the organization.
The More Accurate Target
I’m increasingly convinced that Agent-Native Development is just a waypoint.
The real destination is:
Organizational Knowledge-Native Development.
A few core principles:
- Code is not the asset. Knowledge is the asset.
- Knowledge must be machine-readable, not just human-readable.
- Knowledge should live as close to the code as possible — but not be limited to the repo.
- Agents don’t just consume knowledge. They continuously maintain it.
- Verification capability matters more than generation capability.
- The goal isn’t fewer engineers. It’s less knowledge loss.
The future of software engineering isn’t AI writing more code.
It’s taking the tacit knowledge locked inside a handful of senior engineers’ heads — and making it continuously available as organizational knowledge that humans and machines can both understand, verify, and evolve.
That’s the thing worth building.