Rethinking How We Build in the Generative Era
2026-11-15 · Scott
I've been thinking about how software teams work, and how our processes could or should change now that so much of the work can be done by agents. This is where I've landed so far.
Most teams can feel it already: the old way of doing software development isn't sufficient anymore. Instead of forcing an outdated model on top of a new paradigm, we should adapt, and align with the emerging trends on how best to work in an AI-enabled world.
As I've been researching and learning, I've kept notes. They aren't a finished playbook. Here they are, organized, and I'd like to hear where you agree and where you don't.
Axioms
These are the principles everything else rests on.
- The SDLC becomes a set of feedback loops, not ceremonies. Executable specs, tests, and evals become the process, not meetings and needless reviews.
- Code is cheap. Judgment is expensive. OpenAI's Harness team shipped roughly a million lines with zero written by hand; the engineers' job became steering, not typing.
- Specs are king. The spec is the source of truth, and the code follows from it.
- Small batches. Tiny PRs, short-lived branches, fast merges and rollbacks. The gate to merge stays low.
- Planning and doing are separate. Solve the right problem before solving the problem right.
- Repos must be structured for agent use.
- Manage context as a resource. Shorter instructions, linked docs, less ambiguity.
- Prompts, workflows, and specs ARE code. Version them, review them, and treat them as such.
- Don't give the agent everything. Curtail what it sees and what it can touch.
- Design for quick recovery. Feature flags, automated rollbacks, fix-forward loops.
Team Structure
Small and cross-functional. Around five people, depending on scope:
- Product Owner
- Tech Lead
- 2 Engineers
- 1 SRE / Evals / Analyst (optional)
The last seat matters more than it used to. When agents write the code, someone has to own whether it actually works in the world.
Platform
- Blessed templates and patterns. Separate projects and repos that serve as building blocks for any new project, across frameworks. They're kept current with prompts, cron jobs, and agents, so every team starts from a known-good baseline instead of a blank page.
- Shared skills and hooks. Build them once so agents can do everything they need to using shared resources, not one-off setups per team. NVIDIA did a version of this at scale, building custom Cursor rules to automate whole workflows across 30,000+ engineers.
- A shared, standard runtime. Everyone works on the same environment(s): sandboxing, tool allowlists, secure credentials, and logging.
SDLC
- Set up the repo for agents. CLAUDE.md / AGENTS.md and a docs folder.
- Spec-driven development. Hard rules, written down. GitHub's open-source Spec Kit is built around the same idea.
- Explore → Plan → Implement → Commit. This is the loop Anthropic recommends for Claude Code.
- Plan stages make sure we solve the right problem.
- Implement. Agents write, humans supervise.
- Test as much as possible. Unit and integration.
- Review. Either an agent-to-agent loop, or one agent pass and then to the humans.
- Limit merge gates. Keep PRs as short-lived as possible.
- Loop for IaC and operations work. Getting initial deployments going.
- Roaming cleanup agents. Background refactor PRs that auto-merge after quick reviews and tests.
Norms
- Short and sweet beats too long. Agents degrade as context files grow.
- Agents must be able to run tests themselves.
- Parallel sessions. One agent writes, a different agent reviews. Never the same one.
- Sandbox properly. Enough freedom that we don't restrict the agent, enough walls that we don't have blast-radius issues.
- Continuous evals.
- Bugbot. An automated, roaming bug agent that opens its own PRs.
Cadence
Two meetings. That's it. Everything else runs on its own.
Weekly, 30–60 min: Outcome Planning. Pick one to three outcomes per small team. Write or update the specs, acceptance tests, and evals.
Daily, 10–15 min: Agent Ops Standup. Review active agent PRs, failures, flaky tests, and eval regressions. Decide: redirect, approve, or escalate to humans.
Always running:
- Agents generate PRs in small chunks.
- CI runs tests, policy-as-code, and evals.
- An AI reviewer posts a baseline review.
- A human merges only when satisfied.
Who's Already Doing This
None of this is theoretical. Others are already working this way, and in public.
| Company | What they did | Maps to |
|---|
| OpenAI (Harness team) | Shipped an internal beta product with 0 lines of manually written code, roughly a million lines over five months. Redesigned engineering around specifying intent and feedback loops, and changed merge philosophy for high throughput. | Axioms 1, 2, 4; agent-to-agent review |
| Anthropic (Claude Code) | Formalizes the Explore → Plan → Implement → Commit loop, verification criteria, versioned instruction files (CLAUDE.md), checkpoints and rewind, parallel sessions, and permissioned execution. Claude Code's creator has also shared his own workflow. | SDLC 1, 3; Norms 1, 3 |
| GitHub (Spec Kit, Copilot) | Pushing spec-driven development to replace vibe coding with living, executable specs. Copilot is moving from "pair programmer" to an independent agent that plans, runs tests, and iterates while you stay in control. | Axioms 3, 8; SDLC 2 |
| NVIDIA (via Cursor) | Deep GenAI integration across the SDLC (code, review, tests, debugging) for 30,000+ engineers, with customized rules and workflows. Reports 3x code commits with bug rates flat. | Platform 1, 2 |
Where This Goes Next
The tools have changed. The way we work should change with them.
If you're working through the same questions, or you'd like help putting some of this in place on your team, our AI engineering assessment is where we usually start. Or just write to us.
Sources
- Harness engineering: leveraging Codex in an agent-first world — OpenAI, Feb 11, 2026
- Best practices for Claude Code — Anthropic, Claude Code docs
- The creator of Claude Code just revealed his workflow — VentureBeat, Jan 4, 2026
- GitHub Spec Kit — GitHub; announced Sept 2, 2025 (Visual Studio Magazine)
- GitHub Copilot: Meet the new coding agent — GitHub, May 19, 2025
- NVIDIA commits 3x more code across 30,000 developers with Cursor — Cursor, Feb 6, 2026; also Tom's Hardware
Related: Evolving Software, on what we can borrow from nature when software starts to grow on its own.