High-Quality Software Engineering With Agents

Use this module when you are moving beyond a quick prototype and asking an agent to build software that you expect to keep, share, or depend on.

Coding agents can produce changes faster than you can inspect them. Without a clear process, that speed can create code that appears to work but is difficult to understand, verify, or safely change.

High-quality agentic engineering means remaining accountable for the result. It means planning before implementation, testing and reviewing what the agent produces, and using feedback loops that help it correct mistakes. It also means saving what each project teaches you as documentation, tools, and reusable skills. The goal is software that works now and a process that makes the next change easier.

How to produce high-quality work

• Grill — make the agent interrogate you first: goals, constraints, edge cases, what “done” means.
• Spec — converge on a written spec.
• Tickets — cut the spec into small, independently verifiable units. Boundaries make work parallelizable and reviewable.
• Implement — run the improvement loop (below) in parallel, per ticket, on different branches.
• Review — a fresh agent attacks the diff critically to make sure it’s high quality. Must be fresh context!

How to make changes safely

• Checkpoint — commit/save before every change using git, so you can go back to previous working state.
• Test — build new tests and run existing tests to make sure the changes add new good behavior and break nothing.

Testing tips

1. Add behavioral tests. “Add behavioral tests to ensure all important behaviors always work, now and forever.”
2. Test in a real browser. “Use headless Chrome so you can automatically test all the actual user flows.”
3. Optimize your tests. “Optimize the tests using best practices so they run faster and more efficiently!”
4. Adversarial testing. “What are all the likely ways our app might break or not work or not be able to handle certain cases? Please test against all of those cases in advance. What is every likely failure mode.”
5. Add tests for bugs. “Hey, we have this bug. Can you add a test which will replicate it and successfully guard us against regressions. Make sure to document what regression we’re defending against so we don’t delete this.”

Starting Points

1. Begin with Simon Willison’s Vibe engineering. It separates careless code generation from professional work with agents. Look for the established engineering practices that become more important, not less important, when code is cheap to produce.

2. Read Compound Engineering. Its cycle—plan, work, review, and compound—covers the full software development process with agents. The final step matters most: save what the project taught you so the next task starts with better instructions, tools, tests, or documentation.

3. Meet three toolkits through the essays that explain how their creators use them:

   • The Compound Engineering article above introduces Every’s Compound Engineering plugin.
   • Jesse Vincent’s Superpowers: How I’m Using Coding Agents introduces the Superpowers toolkit.
   • Matt Pocock’s 5 Agent Skills I Use Every Day introduces Skills for Real Engineers.

   Each toolkit turns practices such as planning, debugging, testing, review, and verification into reusable skills that help an agent stay on track.

Deep Dive

• HumanLayer’s Skill Issue: Harness Engineering for Coding Agents is a deeper guide to tests, type-checks, hooks, and other feedback mechanisms that push an agent to correct its work before it stops.
• Anthropic’s Harness Design for Long-Running Application Development shows a generator-evaluator loop applied to software projects. It connects repeated evaluation and revision to the roles that code review and quality assurance play in ordinary software development.
• Birgitta Böckeler’s Harness Engineering explains how teams build environments that help coding agents succeed.