At my current employer, I do not expect developers to memorize every coding standard. I expect them to know the standards exist, understand how the guidance is organized, and look up the relevant material when the task calls for it.
AI agents get the same treatment. We give them a small base layer of standards, golden rules, and agentic workflow guidance. Those documents tell the agent how to approach the work and where to find the next relevant instruction. A UI task loads UI standards. An API task loads API standards. Data access, infrastructure, testing, and security each have their own modules. The code map directs the agent to the part of the system it needs to understand before it starts changing code.
This is onboarding performed in a new medium.
The industry is excited about agent loops and spec-driven development because they make AI coding more reliable. The reason they work is much less mysterious. They give AI workers the same things good managers give junior developers: the right context, delivered at the right time, inside clear boundaries.
The First Assignment
No competent manager starts a new developer with, “Here is the entire product. Make it better.” The developer gets a small, specific task. They learn the repository, the conventions, the people who own adjacent systems, and the definition of done for that task. During those early tasks, they should be consulting the relevant standards regularly instead of relying on partial memory or a guess about what the team expects. They receive more responsibility as they demonstrate that they can handle it.
The same approach works for agents. A useful feature definition gives the agent a clear outcome, relevant business context, acceptance criteria, constraints, and non-goals. Stories reduce that work into units small enough to build, test, inspect, and finish. The agent can then make progress against an explicit unit of work instead of guessing at scope, behavior, and completion criteria.
Without those boundaries, an agent behaves much like an inexperienced developer under time pressure. It finds the easiest plausible path to a working result. That path may compile and pass a narrow test while still putting business logic in a controller, hardcoding a prompt in a UI component, or collapsing data access and display behavior into one place.
The agent did what it was asked to do. The organization failed to tell it what good work looked like.
A Specification Is a Work Order
Spec-driven development can sound like a new software methodology. In practical terms, it is a disciplined work order for a capable worker who lacks your organizational memory.
A useful specification answers questions that would otherwise be hidden in a manager’s head or scattered across old tickets. What outcome matters? Which behavior must remain unchanged? What is outside the task boundary? Which architectural constraints apply? How will the team know the work is complete? What should the worker do when the requirement conflicts with the current code?
GitHub’s Spec Kit follows this sequence: establish project principles, define the specification, make an implementation plan, break the plan into tasks, and execute the work. It is one implementation of a pattern that is becoming common. My team uses obra’s Superpowers and its writing-plans skill. The Claude and GitHub Copilot CLI harnesses we use also provide planning modes. Different tools, same discipline: turn a rough request into a reviewable plan before implementation begins.
This is why vague requests produce fragile AI output. “Build the feature” leaves the important decisions unstated. A detailed feature and a set of clear stories turn those decisions into context that can be loaded at the unit of work.
Context Is Not a Document Dump
The junior-developer comparison needs one important qualification. Junior developers do not carry every document about a system in their head, and neither should an agent. Both need appropriate documentation when they reach the decision that requires it.
That is why our AI standards are modular. The base documents establish the rules of engagement and route the agent to task-specific material. The agent reads the code map to find the relevant part of the repository, then loads the architectural, testing, or operational guidance that applies to that work. It does not spend context trying to retain standards for a database migration while changing a view.
This is also where some of the current agent discourse gets sloppy. More context is not automatically better context. Anthropic describes context as a finite resource that must be curated because excessive or irrelevant material can reduce focus and create confusion. Its recommendation is progressive disclosure: let the agent retrieve and load relevant detail as it learns what the task needs. Effective Context Engineering for AI Agents
A recent preprint on repository-level AGENTS.md files offers a useful warning. Across the tasks it studied, broad context files reduced task-success rates while increasing inference cost. While it is one study and not a final verdict on instructions files, it does reinforce the practical lesson: give an agent a map and a routing mechanism, not a warehouse of binders. Evaluating AGENTS.md
The Loop Needs a Definition of Done
An agent loop is a worker repeatedly taking action, observing a result, and choosing the next step. That is useful only when the system can tell whether the work is moving toward a real finish line.
For coding work, the finish line should be explicit. Acceptance criteria are met. Required tests exist and pass. The build is clean. The scorecard meets the agreed threshold. The pull request receives review. When the agent cannot meet one of those conditions, it should report a specific blocker or ask for a decision. It should not simply keep spending tokens in the hope that another iteration will make the uncertainty disappear.
The code scorecard is part of that definition of done. Human and AI developers both use it to see where an implementation is strong, where it is weak, and what should improve next. It turns “good code” from a private judgment into an explicit, objective definition.
That is how a manager handles a junior developer as well. You do not tell them to keep working until the task feels complete. You give them a definition of done, expect them to say when they are stuck, inspect the result, answer questions that require judgment, and let the next task build on verified work.
Anthropic’s evaluator-optimizer pattern and OpenAI’s agent guidance both reach the same conclusion from the technical side. Useful loops need evaluable criteria, bounded actions, and a path to human oversight when risk or uncertainty rises. Anthropic on effective agents and OpenAI’s practical guide describe the mechanisms. Engineering management provides the older vocabulary for why they work.
Autonomy Grows Inside Boundaries
This does not mean every agent task needs a human staring at every tool call. It means autonomy should grow from demonstrated reliability inside a defined operating environment.
The first task may be a small bug fix with required tests and a mandatory pull request. The next may be a feature with several stories. After enough clean results, the team may allow the agent to run implementation, tests, and scorecard checks independently before a human reviews the pull request. The task boundary expands because the team has evidence that the workflow, standards, and verification mechanisms are holding.
That is how competent organizations develop people. It is also how they should develop agentic workflows.
Good Management Updates the Playbook
My coding standards and agentic guidance did not come from a template. They came from experience. As I manage a team, I learn which practices help individual developers and which patterns help the team deliver more reliably. I adjust the process based on what I observe.
Agentic guidance needs the same treatment. New models arrive with different strengths, weaknesses, and failure modes. A workflow that is clear for one model may leave another model enough room to make the wrong assumption. When the same pitfall appears repeatedly, the correct response is to improve the guidance instead of relying on a human to remember the warning every time.
I have asked an agent after a miss, “What would have helped you avoid that?” When its answer identifies missing context, an unclear constraint, or an absent verification step, I have it update the relevant guidance. The individual mistake becomes a durable improvement to the system around future work.
That is how managers turn experience into a better team. It is also how an agentic workflow gets better over time.
The Context Must Survive the Session
The analogy ends at a critical point. A human developer accumulates memory, relationships, and judgment over time. An agent may begin the next session with none of the contextual understanding it built during the last one.
Anthropic describes long-running agent work as a project staffed by engineers working in shifts, where each new engineer arrives without memory of the previous shift. Its proposed solution is an initializer that establishes the environment, incremental tasks, and artifacts that explain the next useful step. Effective Harnesses for Long-Running Agents
That makes documentation, comments, decision records, code maps, and task handoffs more important in an agentic codebase. They function as durable memory, letting the next agent orient before it acts. The quality of the next session depends in part on what the previous session leaves behind.
Good AI Management Is Just Good Management
Agent loops, spec-driven development, planning modes, and evaluator agents can look like a new management discipline because the technology is new. The underlying work is familiar. Give a worker enough relevant context to begin well. Scope the task. Make the standards available. Define done. Expect escalation when the worker is stuck. Inspect the result. Turn repeated mistakes into better guidance. Preserve what the next worker needs to know.
Good managers already do this for junior developers. The AI version demands that the practices become more explicit, because an agent does not carry forward the organizational memory and judgment that a person slowly acquires. The system has to carry more of that context on the team’s behalf.
Good AI management is just good management made explicit enough for a machine.
Receipts
- Modular standards in production: At my current employer, agent sessions begin with base standards, golden rules, and agentic workflow guidance. Task-specific modules load only when relevant, and the agent uses a code map to locate the appropriate system area. The public agentic coding standards repository demonstrates the modular approach.
- Planning before implementation: GitHub Spec Kit structures agentic work around project principles, specifications, plans, tasks, and implementation. My team also uses obra’s Superpowers, including its
writing-plansskill, alongside planning modes in Claude and GitHub Copilot CLI. - Context curation: Anthropic argues that agent context is finite and recommends progressive disclosure over loading exhaustive context at once. Effective Context Engineering for AI Agents
- Counterevidence to context dumping: A 2026 preprint found that the repository-level context files it tested could reduce coding-agent task success while increasing inference cost. It is a warning about broad, poorly targeted context, not an argument against instructions or standards. Evaluating AGENTS.md
- Shared quality feedback: Human and AI developers use the code scorecard to identify where an implementation is strong, weak, and ready for improvement. It makes the team’s definition of good code visible at the end of a task.
- Verification and escalation: Anthropic documents evaluator-optimizer workflows, while OpenAI recommends explicit guardrails and human intervention for high-risk actions. Anthropic and OpenAI
- Session handoffs: Anthropic’s long-running-agent guidance recommends environment setup, incremental progress, and artifacts for the next session because a new agent begins without the predecessor’s memory. Effective Harnesses for Long-Running Agents