Engineering With Agents
Adopting a coding agent changes the tools you use. Building your workflow around agents changes how you work.
Agents can implement changes, run checks, and correct failures across multiple steps. Working effectively with that capability means preparing tasks they can carry forward, giving them usable tools, and reviewing outcomes without directing every edit.
The engineer increasingly designs the setup that allows agents to build software. Requirements, repository structure, validation, and access controls all become part of that setup.
These ten principles describe what that change asks of us.
1. Make intent the starting point
More of the engineer's work moves into describing the desired behavior and evaluating what gets built. Define requirements, constraints, important edge cases, and acceptance criteria before implementation. An agent should know what a successful result looks like and how to demonstrate it. Clear intent gives both the implementation and the review a common reference.
2. Give agents longer stretches of useful work
Assign tasks that include implementation, testing, and correction, then let the agent work through routine failures. Independent tasks can run in parallel, with results reviewed asynchronously. As the setup becomes reliable, extend the amount of work agents can complete between interventions. The aim is to create time for other engineering decisions while execution continues.
3. Make the codebase understandable to a fresh session
Every new session needs to recover the project's conventions and reasoning. Keep architecture notes, setup commands, and coding rules discoverable. Use clear module boundaries and types, and capture specialized procedures in reusable instructions. Have agents record important design decisions as they work so future sessions inherit the reasoning. In a large repository, prepare and delegate one area at a time.
4. Make verification available to the agent
Fast, local, automated checks allow an agent to detect a mistake and attempt a correction before you review the result. Provide test commands, useful errors, local service mocks, and a browser for inspecting UI changes. Include checks for required behavior and invariants, so validation goes beyond confirming that the generated code runs. The agent needs access to the tools that tell it whether its work is correct.
5. Put more effort into choosing the direction
When implementation becomes easier to explore, decisions about the product and architecture deserve more attention. Use agents to investigate options, challenge assumptions, and prototype competing designs. Compare the evidence before committing. Spend particular care on API contracts, dependencies, and system boundaries: these decisions shape future work long after the first implementation has changed.
6. Be willing to replace the implementation
A prototype can answer a useful question and still be discarded. Avoid carrying an unsuitable design into production simply because the code already exists. Preserve the requirements, lessons, and tests that protect behavior at stable boundaries. Those form a contract for the next implementation. Continue to judge the feature by its value and the cost of operating and maintaining it.
7. Keep the quality bar as output grows
Generated code carries the same obligations for correctness, security, and maintainability as any other contribution. Review closely while learning where agents fail, and use automated reviewers to catch recurring problems. Focus human judgment on architecture, system interactions, and consequential decisions. Ownership extends through deployment: verify production behavior and make regressions part of the work that agents help investigate and fix.
8. Enforce the boundaries that make autonomy possible
Longer independent work needs controls that remain effective when nobody is watching. Limit access to files, tools, networks, and credentials through the environment. Grant production access deliberately and keep explicit gates around actions that are difficult to undo. Security checks and secret scanning add protection beyond functional tests. Expand autonomy as you gain evidence that these controls work.
9. Use the same approach across engineering
Planning, design documents, incident investigations, release preparation, and operational work can all benefit from agents. Give each task the relevant context, a clear outcome, and a way to assess the result. Reuse project knowledge and tooling across these workflows, with access appropriate to each task. The opportunity extends across the work required to build and run software.
10. Keep improving the agent setup
Treat repeated mistakes and interruptions as information about what the setup lacks. Add a missing convention, automate a manual step, improve access to context, or repair an unreliable tool. Check whether the next task improves. As models and tools change, revisit old workarounds and remove those that no longer help. Maintaining this setup becomes an ongoing engineering responsibility.
The initial investment can feel slower: documentation, test infrastructure, and task design all take time. The aim is to support longer periods of useful agent work while preserving your attention for direction, judgment, and quality.