Skip to content

AI-Assisted Delivery Methodologies Compared: Which One Fits Your Team?

Vibe coding, spec-driven development, AWS AI-DLC, test-first agents and more, compared side by side, with pros, cons and the team structures each one fits.

Series · AI-Native Development · Part 1 of 6

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.

Eight approaches on two axes, placed from the comparison table below. Point at, or tap, a number.
Cheap guardrailsHeavy and well guardedFast and unguardedEffort without enforcementEffort upfrontnonehighestHow hard it is to ship unchecked code12345678

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
Which AI delivery approach fits your team? Answer the questions; the path you take stays open.

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:

Action Items:

  1. Write down how your team uses agents today, and which of the eight approaches it is closest to.
  2. 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.
  3. 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

Responses

Checking your session.

Loading responses.