For tech leads, developers and delivery leads choosing how their team works with AI coding agents, and for Salesforce admins whose teams are starting to. The terms table and the admin-led team row cover what admins need.
TL;DR
- At least eight named approaches exist for delivering software with AI coding agents, from vibe coding and spec-driven development to AWS's AI-DLC and the Intent → Spec → Test model I have been developing.
- They fall into three layers: how one developer works with an agent, how you prove the agent built the right thing, and how a whole organisation is set up. Most teams use something from each.
- They differ on where the thinking happens and how hard they make it to ship code nobody checked.
- The evidence is mixed: METR's 2025 trial found experienced developers 19% slower with AI while believing they were faster, and DORA's 2025 report links AI with both higher throughput and more change failures.
- Match the method to the team: a fast test loop for small teams, specs where there are contracts and hand-offs, and linked specs, tests and gates for regulated multi-team work.
What You'll Learn
- What each of the eight approaches is, in plain terms, and where it came from
- A side-by-side comparison of artifacts, upfront cost, guardrails and failure modes
- The real pros and cons of each, including the ones their advocates skip
- Which approach fits which team structure, from a solo builder to a regulated multi-team programme
- How to mix approaches by risk in one repository
The Problem
Many teams adopted AI coding tools one developer at a time. Someone installs Cursor or Claude Code, gets faster at writing code, and the team's process stays the same. Then the pull requests pile up, review turns into rubber-stamping, and change failures creep up.
The tools moved faster than the methods. There are now named methodologies for working with agents, and vendors, consultancies and practitioners each have one. They overlap, they use the same words for different things, and few of them say which kind of team they suit.
Common Questions This Article Answers:
- Is spec-driven development just waterfall with an AI on the end?
- Do I need a methodology at all, or can my team keep vibe coding with tests?
- Which approach fits my team, and does that change as it grows?
Quick Answer
Choose by team shape. A solo builder should use vibe coding for throwaway prototypes and a minimal loop (fast tests, small commits, agent iterating against the diff) for anything real. A small product team should add test-first discipline so agents cannot write tests shaped to pass. Teams with API contracts, migrations or several hand-offs benefit from spec-driven development (spec-kit or Kiro). Enterprise and regulated programmes with many parties need something heavier: AI-DLC's team rituals, or a model that links intent, spec and tests by ID and checks the links in CI. Whatever you pick, put the WIP limit on the review queue, because that is where AI delivery jams.
A few words you will see
| Term | What it means here |
|---|---|
| Agent | An AI assistant that takes actions, such as editing files and running commands |
| CI | Continuous integration: checks that run automatically on every proposed change |
| Spec | A written description of what correct looks like, before anyone builds it |
| Must-never | A line the business says can never be crossed, such as "a guest user must never read Contact records" |
| Hidden test | A test the agent never sees, like exam questions a student has not seen, so passing it proves more (also called a held-out test) |
The Eight Approaches, in Three Layers
These eight are not all alternatives to each other. Some describe how one developer works with an agent; some describe how you prove the agent built the right thing; some describe how a whole organisation is set up. A team might use AI-DLC for its rituals, harness engineering as its platform strategy, and Intent → Spec → Test for its riskiest changes, all at once.
The top left is where the cheapest guardrails sit. Approaches high on effort but low on enforcement depend on someone keeping their artifacts true.
Reading the map: up means harder to ship code nobody checked; right means more effort before the agent starts. The positions are my assessment from the comparison table below, not measurements. Intent → Spec → Test sits top right because it closes every gap the others leave, with a machine check for each, and asks the most upfront work to do it. Being top right does not make it the best choice: that is the expensive corner, and for most changes the cheap guardrails in the top left are the better buy. The full reasoning is in why Intent → Spec → Test works.
Layer 1: The developer loop
1. Vibe coding
Andrej Karpathy named it in February 2025: you describe what you want, accept what the model writes, and judge it only by running it. You do not read the code.
Use it for: spikes, demos, personal tools, anything you would happily delete.
2. The minimal loop
A lean instruction file (CLAUDE.md, AGENTS.md), a fast test suite, small commits, and an agent that iterates against git diff until the tests pass. No meta-framework. This is the working style Simon Willison and many experienced practitioners write about.
Use it for: experienced developers on codebases they know.
3. Structured-Prompt-Driven Development (SPDD)
From Thoughtworks' internal IT team: prompts are first-class artifacts, versioned in the repository next to the code and reviewed in the same pull requests.
Use it for: teams standardising how they prompt, especially across many developers.
Layer 2: Verification and contracts
4. Test-first agents
TDD applied to agent-written code. Tests are written, or at least specified, before the agent writes code, and two extra rules stop gaming: new tests must fail on the old code before they pass on the new, and some tests are hidden from the agent entirely and run only in CI.
Use it for: business logic, security rules, anything where a wrong answer is expensive.
5. Spec-driven development (SDD)
Write a specification first, and let it drive the agent. Birgitta Böckeler of Thoughtworks describes three levels: spec-first (write a spec, use it, let it go), spec-anchored (keep the spec and update it as the feature changes), and spec-as-source (people edit the spec; code is generated from it). The main tools are GitHub spec-kit (a constitution of project principles, then /specify, /plan and /tasks), AWS Kiro (requirements.md in EARS notation, "WHEN [event] THE SYSTEM SHALL [behaviour]", plus design.md and tasks.md) and Tessl, which aims at spec-as-source.
Use it for: APIs, data contracts, migrations, features with several hand-offs.
6. Intent → Spec → Test
The model I have been developing, which combines several of the above. Three layers, each written by people before the agent starts: intent (the outcome and a "must never" list), spec (concrete rules in when/then form), and tests (visible ones the agent iterates against, and hidden ones it never sees). Every item cites the one above it by ID, and CI fails the build if a must-never has no rule, a rule has no test, or a must-never has no hidden test. A Salesforce example: "a guest user must never read Contact records" becomes a rule and a hidden Apex test that only CI can see.
Use it for: high-risk changes only, such as authentication, permissions, billing and guest access; applied to every change it becomes a traceability bureaucracy. The how-to, including where to keep hidden tests and when not to use it, is in Intent → Spec → Test: Linking Must-Nevers to Held-Out Tests.
Layer 3: Operating model
7. AWS AI-DLC (AI-Driven Development Lifecycle)
Introduced by AWS in July 2025 and available as a workflow in Kiro. Three phases: Inception (AI turns intent into requirements and units of work, validated by the team in "mob elaboration" sessions), Construction (work happens in "bolts" of hours or days instead of sprints, with "mob construction" sessions on design decisions), and Operations.
Use it for: larger teams adopting AI across the whole lifecycle, particularly on AWS.
8. Harness engineering ("humans on the loop")
Kief Morris of Thoughtworks distinguishes humans in the loop (checking every output, which degrades into rubber-stamping at volume) from humans on the loop (designing the system that produces and checks the software). The specs, checks and workflow guidance around the agent form its harness.
Use it for: tech leads and architects designing how a whole team works with agents.
Side-by-Side Comparison
| Layer | Approach | Main artifact | Where the thinking happens | Upfront cost | How hard it is to ship unchecked code | Typical failure |
|---|---|---|---|---|---|---|
| 1 | Vibe coding | None | In the prompt | None | Easy | Unmaintainable code, silent bugs |
| 1 | Minimal loop | Instruction file, fast tests | In the developer's head | Low | Medium | Tests that pass for the wrong reason |
| 1 | SPDD | Versioned prompts | In the prompts | Medium | Medium | Good prompt, wrong outcome |
| 2 | Test-first agents | Visible and hidden tests | In the tests | Medium | Hard | Weak tests, if nobody checks them |
| 2 | Spec-driven (spec-kit, Kiro) | Spec, plan, task list | In the spec | High | Medium | Spec drifts from the code |
| 2 | Intent → Spec → Test | Intent, rules, tests, linked by ID | In all three, checked by CI | Highest | Hardest | Too heavy for small changes |
| 3 | AWS AI-DLC | Requirements, units, bolts | In mob sessions | High | Medium to hard | Rituals become ceremony |
| 3 | Harness engineering | CI gates, hooks, guidance | In the harness | Medium | Hard | Gates people route around |
The approaches that put the thinking in tests or gates are the ones that stop unchecked code, because a machine enforces them. The ones with the highest upfront cost pay for themselves only where mistakes are expensive.
Mixing Approaches by Risk in One Repository
Most teams should not pick one approach for everything. Route each change by how much damage a mistake would do:
| Tier | Example changes | Approach | What it costs |
|---|---|---|---|
| 1. Low risk | Layout changes, copy, internal tooling | The minimal loop | Fast tests, no spec |
| 2. Medium risk | New endpoints, integrations other teams use, data migrations | Spec-first development plus test-first | Write the contract first, then build and test |
| 3. High risk | Authentication, permissions, billing, guest access, data retention | Intent → Spec → Test | Must-nevers, linked rules, hidden tests in CI |
How to route changes into tiers automatically is covered in the Intent → Spec → Test deep dive.
Starting From an Existing System
Most spec-driven writing assumes a system you understand. In an older org or a legacy monolith, map current behaviour first with a read-only agent and characterization tests (Michael Feathers' term for tests that record what the system does today), and only then write the new spec and must-nevers.
Which Team Structure Fits Which Approach
| Team shape | Best fit | Add as it grows | Avoid |
|---|---|---|---|
| Solo builder | Vibe coding for prototypes; minimal loop for real products | Test-first where money or data is involved | Heavy process |
| Small product team | Minimal loop plus test-first | Spec-first for larger features | Heavy rituals |
| Platform or API team | Spec-anchored SDD plus test-first | Harness engineering | Vibe coding near a contract |
| Admin-led Salesforce team | Plain-language must-nevers; Agentforce Vibes Plan Mode; sandbox first | Flow tests; test-first for Apex | Agents with write access to production |
| Many juniors or new joiners | Test-first plus harness engineering | Review, then tests, then directing agents | Directing agents before they can write good tests |
| Consultancy for a client | Intent → Spec → Test; must-nevers double as sign-off | AI-DLC mob elaboration in workshops | Process the client cannot audit |
| Large organisation | AWS AI-DLC, or SDD plus SPDD | A platform team owning the harness | Every team inventing its own |
| Regulated, multi-team, shared platform | Layered Intent → Spec → Test plus harness engineering | AI-DLC rituals across teams | No hidden tests or CI-only deploy path |
Will the code be thrown away (a spike, a demo, a personal tool)?
Eight approaches, one fit
Start at the top. Each answer opens the next question, and the panel gives the approach to start with and what to add as the team grows.
A note for Salesforce teams
Most of these approaches were designed for code, and a lot of Salesforce delivery is configuration. Test-first and mutation testing apply cleanly to Apex and only partly to Flows and metadata, where checks have to be Flow tests and queries against what was deployed. For admin-led teams the spec half (clear rules, must-nevers) pays off immediately; the test-and-gate half still needs adapting.
Whatever the approach, the agent's own access needs governing too: which MCP servers can reach your orgs (third-party MCP server governance), and a CI deploy user that holds only what it needs (deployable permission sets for a delivery team).
Frequently Asked Questions
Q: Is spec-driven development just waterfall?
A: It can become waterfall if the spec has to be complete before anything starts and nobody revisits it. The spec-first and spec-anchored styles avoid that by keeping specs small (one feature, one change) and updating them as the feature evolves. The risk grows as the spec gets more detailed: a spec precise enough to remove every ambiguity is effectively code, written in a worse language.
Q: Which approach gives the best productivity gains?
A: There is no good comparative data yet. METR's randomized trial found a 19% slowdown for experienced developers using early-2025 tools on code they knew well, and DORA's 2025 report found throughput up but instability up too. Whichever approach you choose, baseline your cycle time and change failure rate before rollout and measure again after a few months.
Q: Do these approaches replace Scrum?
A: Mostly they replace parts of it. AI-DLC replaces sprints with bolts. The others leave the cadence alone but change what "ready" and "done" mean, and move the bottleneck from building to checking. The closest ancestor of most of them is XP: test-first, continuous integration and small releases.
Key Takeaways
- The approaches sit in three layers, and most teams need one from each. They are not eight rival choices.
- The ones that put the thinking in tests and gates are the ones machines can enforce.
- Spend upfront effort in proportion to what a mistake would cost, and route changes by risk.
- Whatever you pick, review becomes the bottleneck. Put the WIP limit on pull requests waiting for review, make CI gates your Definition of Done, track change failure rate and lead time instead of velocity, and measure before and after: in METR's trial people felt faster while being slower.
What's Next?
Recommended Reading:
- Intent → Spec → Test: Linking Must-Nevers to Held-Out Tests, and When Not To, the deep dive on approach 6
- Salesforce in Claude: Token Cost of OrgPulse vs DX MCP vs the sf CLI, measured cost of different agent tooling
- Third-party MCP server governance for Salesforce, controlling what agents can reach
- Post-ForcedLeak: Hardening Agentforce Against Prompt Injection, the agent as an attack surface
Action Items:
- Write down how your team uses agents today, and which of the eight approaches it is closest to.
- Measure how long changes take from request to production, and how often a release causes a problem, before changing anything. If you deploy with change sets or DevOps Center, a simple log of deployments and rollbacks is enough to start.
- Pick one approach for one type of change (for example, test-first for business logic) and run it for a month before expanding.
Resources & References
- Kief Morris: Humans and Agents in Software Engineering Loops
- Birgitta Böckeler: Understanding Spec-Driven Development: Kiro, spec-kit, and Tessl
- Structured-Prompt-Driven Development (SPDD)
- AWS: AI-Driven Development Life Cycle
- Kiro: Specs
- GitHub spec-kit practical guide
- METR study, summarised by Simon Willison
- DORA 2025 State of AI-assisted Software Development (InfoQ)
Responses
Checking your session.
Loading responses.