DEV Community

Vidya Krishnan
Vidya Krishnan

Posted on Edited on

AI-native SDLC

My experience with an AI-native SDLC: a working diary

I wanted to explore how the software development lifecycle (SDLC) changes when a new player joins it: AI. I think AI will eventually be a mandatory part of how we build software. So why not embrace it now, start preparing, and work out how we keep our own role in the lifecycle? I decided to try Anthropic's AI-native SDLC playbook while building my next hobby project, and to keep a diary as I went.

The short version is on this page. Click any "Read more" to open the details.

The project

GhostGearFinder scores 1 km patches of UK seabed by how likely they are to hold lost fishing gear (gillnets, trawls and longlines), using open data on fishing, seabed and currents. It then checks those scores against places where gear was actually found, so recovery teams know where to look first.

The stages of an AI-native SDLC

The playbook's premise is that agents now write code far faster than teams can plan, review and approve it. So the slow human steps move into short files in git that both people and the agent read. It has six stages:

Stage What happens File it lives in My job Claude's job
1. Plan Agree what to build and why intent.md Write the what, why and constraints Ask questions, tighten the wording
2. Design Turn the intent into a spec requirements.md, design.md Review and correct Draft numbered requirements and a design
3. Build Plan the work, then write the code plan.md, CLAUDE.md, code Approve the plan Plan first, then build against the plan
4. Test Show the build does what was planned tests, build-log.md Decide what "good" means Run the tests after every change
5. Deploy Ship it pull requests, CI Review the parts that matter First-pass review; checks that block unapproved actions
6. Maintain Watch it in use metrics Set what "healthy" looks like Watch the metrics; a problem becomes a new intent

Gates

A gate is a checkpoint at the end of a stage. The developer reviews the stage's file, resolves every question in it, adds any other relevant information, and approves it only when the stage has everything it needs to proceed. The agent can draft, but only a human can pass a gate: in my repo, CLAUDE.md says Claude never marks a gate approved.

Why bother? In scientific data work, the costly mistakes are rarely bugs. They are quiet method errors, like testing a model on the same data you tuned it on. A gate is where someone stops and asks whether the plan is right before the agent builds on it.

How stages and gates work together

Each stage produces a file, each file passes a gate, and the approved file becomes the input to the next stage:

Every stage hands its file through a human gate: intent, G1, requirements and design, G2, plan, G3, code and tests, G4

Two things stop this from becoming a rigid waterfall:

  • Change requests. When I change my mind, I don't edit an approved file directly. I write a short change request (the problem, the proposal, the evidence), and it's decided at the gate of the file it changes. If it's approved, that gate re-opens until the change is folded in and approved again.
  • The loop. In the maintain stage, a problem spotted in the metrics becomes a new intent, and the cycle starts again.

Change requests aren't one of the playbook's stages. They're how I learned to change my mind safely, and they became the heart of the process.

How the tracker keeps track

I keep a tracker: a spreadsheet in the repo that gives the overview, so I don't have to read the git log to know where things stand. The official record is still git, where each decision is one commit, with who made it and when.

Read more: the tracker's five tabs
Tab What it shows
Summary Counts of each status, calculated from the other tabs
Gates The four gates, with status, approval date and commit ID
Change requests Every CR, with status, decision date and a link to its write-up
Data access Every dataset, its licence, and whether it has been requested, granted or refused
Open questions Each question from the intent and change requests, with its answer

Status cells are dropdowns, colour-coded, and the cells I'm meant to edit are yellow. After each commit, the tracker is updated to match, including the commit ID.


Entry 1: From idea to running code in an afternoon

Lesson: gates are cheap only if you pass them before building.

Read more: what we built, my first mistake and how I fixed it

I started with a rough proposal and asked Claude to follow the playbook. By the end of the afternoon we had:

What What it holds Why it mattered
intent.md One page: what we want, why, who it's for, constraints and open questions Two constraints did a lot of work later: "software only, open data" and "no accuracy number before it is measured against baselines on held-out areas"
requirements.md, design.md Twelve numbered requirements, each with an acceptance check, and a design Every test now names the requirement it covers
plan.md, CLAUDE.md Milestones, a task list, and the repo's standing rules Every Claude session reads the rules first
A tested prototype pipeline Code running on a synthetic region with gear planted in it Every metric had a known right answer

My first mistake: I asked for the build straight away, before approving anything. Every file said "DRAFT, awaiting gate approval", and the code existed anyway. It worked out, but I had skipped the point of the playbook.

How I fixed it: I relabelled the code as a prototype, froze it, and let the design and plan gates decide what survives. CLAUDE.md now says no new feature code until gate 3 is approved; only bug fixes and tests are allowed. Spikes are fine, but only when the intent says it's a spike.

My first lesson: the very first run showed a dumb rule, gear is near the port, beating the model. It won because people search near port, so that's where gear gets found. We wrote it into CLAUDE.md as a rule: only score places where people actually looked. A surprise became a guardrail instead of a footnote.

Entry 2: A review question becomes a change request

What changed in my process: a change request is not paperwork. It's the place where a hunch gets written down, tested and decided, and it leaves a trail of why.

Read more: the question, the flaw and what the evidence showed

While reviewing the config, I asked something that felt almost too basic: a patch of seabed can be rocky and steep but never fished, so what do the weights actually mean?

The answer exposed a real flaw. The score added the factors together: 0.6 × fishing + 0.3 × rock + 0.1 × slope. That meant a rocky, steep cell that no one had ever fished scored 0.40, almost as high as a fished one. Gear cannot be lost where no gear is set, so fishing should be the driver and the ground factors should multiply it.

In a code-first workflow, I'd probably have changed the formula in place and moved on. Here it went through the process:

  • a change request, CR-001, with the worked example, the proposal and the evidence;
  • the design and requirements documents marked as re-opened, with the gate pending;
  • the new scoring added behind a config switch, so nothing changes until a human approves it;
  • new tests, including one that pins the original question: a rocky, never-fished cell must score exactly 0.

The evidence held a second surprise. Multiplying alone barely helped. The way each layer was rescaled to 0–1 spread the many almost-unfished cells across the whole range, so "no fishing" never actually reached zero. Only multiplying and switching to min-max scaling beat the fishing-effort baseline. A one-line fix would have shipped the half that doesn't work.

Entry 3: Research reshapes the design

What changed in my process: the intent's open questions became my research agenda. Each answer went back into intent.md as a proposed answer, to be confirmed when I approved it.

Read more: the change requests that came out of the research

The intent had three open questions: which UK region and data, whether fishing data exists by gear type, and whether anyone records where they searched. Answering them took a few evenings of reading, and every answer changed the design.

Without the process, I'd have folded each finding straight into the code. Instead, each one became a change request with its own reason and evidence:

Change request What it does
CR-004 Test the model against survey data that records where people looked, including searches that found nothing
CR-005 Narrow the scope to gillnets, trawls and longlines, add missing causes of gear loss, and add a separate "harm" layer for wildlife
CR-006 to CR-008 Three ideas from reading earlier projects, including a baseline that rebuilds today's common method so we can show whether ours does better

Two ideas from the first week were also written up, then rejected or parked. A rejected change request with a reason is useful history: it stops the same idea coming back without new evidence.

Entry 4: Checking every claim

What changed in my process: nothing goes into a file on trust, so the playbook's review step covers research as well as code.

Read more: what the checks caught

Research questions came up all the time: which datasets exist, what their licences allow, what earlier projects found. Some answers came from my own reading, some from Claude's searches, some from other sources. Whatever the source, I asked Claude to cross-check every claim against an original source (a government page, a dataset record, a paper) before anything went into a file, and we decided together what to keep.

Most claims held up, but the checks caught several that would have caused trouble later:

  • A European fishing dataset was said to have no data for static gear. Its own catalogue page lists a "static gears" group.
  • Scottish small-boat maps were described as fishing effort. They show catch value in pounds, from one position per fishing day.
  • Gear-level logbook data was said to be "completely" usable. It is, but it isn't public, so it needs a formal data request.
  • A regulator's decision was cited by a reference number that couldn't be found anywhere.

The rule we settled on: confirmed facts go in with their source; unconfirmed ones go in marked "to verify"; anything that can't be found is marked "do not cite".

Entry 5: Running the gates for real

What changed in my process: the git history now reads like minutes of a meeting. Each commit is one decision, with who made it and when.

Read more: the review rhythm I settled on

By now I had eight change requests and four gates, all pending, and I was confused. What untangled it was giving each its own status: a change request goes proposed → approved or rejected → done; a gate goes pending → approved, and back to re-opened if a later change touches it.

For each document, the rhythm became:

  1. Read one document.
  2. Make sure every question and doubt in it is resolved.
  3. Set its status: approved, rejected, or changes requested (it stays in review until the changes are made).
  4. Commit that one decision in git, with a clear message.
  5. Update the tracker, move to next step.

Decision log so far

Gate 1 (the intent) is approved. Seven of eight change requests are decided; gate 2 (the design) is next.

Read more: every gate and change request, with its status

The gates

Gate Approves The question it answers Status
1 intent.md Are we solving the right problem? Approved, 14 Nov 2026
2 requirements.md + design.md Is this the right solution? Pending (next)
3 plan.md Is this the right next piece of work? Pending
4 Test results Did the build do what was planned? Pending

A gate goes pending → approved. If an approved change request later alters a document it covers, the gate goes back to re-opened until that change is folded in and approved again.

The change requests

A change request (CR) is a written proposal to change a document behind a gate: the problem, the proposal, the evidence and the risks. It doesn't create a new gate; it is decided at the gate of the document it changes. A gate can't be approved while a change request touching it is still undecided.

CR What it changes Gate Status
CR-001 Score by multiplying, not adding; min-max scaling 2 Approved
CR-002 Log-scale fishing effort 2 Candidate, after real data
CR-003 Drift term for nets 2 Rejected, folded into CR-005
CR-004 Test against survey effort, including empty searches 2 Approved
CR-005 Three gear models, new loss causes, harm layer 1 and 2 Approved
CR-006 Vessel traffic and offshore structures 2 Approved
CR-007 Warn when input layers come from different years 2 Approved
CR-008 "Current practice" baseline 2 Approved

A change request goes candidate → proposed → approved or rejected → done (done means built and tested). Rejected ones stay in the repo with their reason.

How I'd roll this out in a team

Running the playbook alone on a side project is one thing. Here is how I would bring it into a team:

  1. Start small and real. One repo, one team, and the next real feature, not a demo.
  2. Agree who approves what. Each gate needs a named owner: for example, the product owner or lead scientist for the intent, a senior developer for requirements and design, the tech lead for the plan, and whoever owns quality for the test results. The agent drafts at every stage but approves nothing.
  3. Write a shared CLAUDE.md for each repo. Commands, conventions and guardrails, kept under a page, because every session reads it first.
  4. Turn repeated know-how into skills. Things the team explains again and again, such as how we write a data ingest or our quality-control conventions, become skills that every session starts with.
  5. Keep the gates in git. An approval is a commit that changes a status line. It's auditable and needs no new tool; a tracker gives the overview.
  6. Put hard rules in settings, not prompts. Claude Code reads a settings file kept in each repo (.claude/settings.json). Permission rules there can stop the agent from, say, editing raw data or pushing to the main branch. Hooks, small scripts that run before or after an action, can block it outright, for example a commit when the tests fail. A prompt can be forgotten; a setting is enforced.
  7. Make fast tests the feedback loop. The agent is only as good as the signal it gets.
  8. Save human review for what matters. People review critical or regulated code closely; agent review takes the first pass on the rest.
  9. Measure it. Track the time from intent to merge, review time, and defects that slip through. A metric outside its agreed range becomes a new intent, and the loop starts again.
  10. Grow by example. Once one team has a few gates and change requests behind it, its repo becomes the template, and its people coach the next team.

What I'd tell a team trying this

  • Pass the gates before you build. It's tempting to let the agent run ahead. The gates only save time if the decisions come first.
  • Your job becomes asking good questions. The agent wrote most of the code. The most valuable thing I did was read the code and config and asked what a number meant.
  • Put guardrails in files, not in your head. Rules like "baselines next to every result" live in CLAUDE.md, so every session follows them without reminders.
  • Write constraints down early, in the intent. "Software only" and "open data only" went into intent.md on day one, and settled later debates in minutes.
  • Change requests are cheap, and that's the point. Writing one up takes minutes and catches the half of a fix that doesn't work. Rejected ones are useful history.
  • Cross-check every claim, whoever found it. Check it against an original source, mark what you can't confirm, and decide together what goes in.
  • One decision per commit. The git log becomes your audit trail; a spreadsheet tracker gives the overview.
  • Fast tests are the feedback loop. Even before any real data, the prototype pipeline runs on a synthetic region with gear planted in it, so every result has a known right answer. Its 19 tests run in about a second, so the agent checks itself after every change.
  • Ask for one step at a time when it gets busy. The process has many moving parts; you only need to see the next one.

What's next

The next entries in this diary will cover the second half of the playbook: approving the design and the plan, then building with real UK data, testing the model on areas it has never seen, and keeping the process honest once real results arrive. I'm also going to request data from several organisations, which is its own lesson in lead times.

If you're trying an AI-native workflow in a research or data team, I'd love to compare notes.

Views in this post are my own and do not necessarily represent BODC or NOC.

Sources

Top comments (0)