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:
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.
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.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
Entry 1: From idea to running code in an afternoon
Lesson: gates are cheap only if you pass them before building.
I started with a rough proposal and asked Claude to follow the playbook. By the end of the afternoon we had: 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. 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 Read more: what we built, my first mistake and how I fixed it
What
What it holds
Why it mattered
intent.mdOne 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
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.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.
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: 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.Read more: the question, the flaw and what the evidence showed
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.
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: 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.Read more: the change requests that came out of the research
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
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.
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: 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".Read more: what the checks caught
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.
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:Read more: the review rhythm I settled on
Decision log so far
Gate 1 (the intent) is approved. Seven of eight change requests are decided; gate 2 (the design) is next.
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. 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. A change request goes candidate → proposed → approved or rejected → done (done means built and tested). Rejected ones stay in the repo with their reason.Read more: every gate and change request, with its status
The gates
Gate
Approves
The question it answers
Status
1
intent.mdAre we solving the right problem?
Approved, 14 Nov 2026
2
requirements.md + design.md
Is this the right solution?
Pending (next)
3
plan.mdIs this the right next piece of work?
Pending
4
Test results
Did the build do what was planned?
Pending
The change requests
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
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:
- Start small and real. One repo, one team, and the next real feature, not a demo.
- 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.
-
Write a shared
CLAUDE.mdfor each repo. Commands, conventions and guardrails, kept under a page, because every session reads it first. - 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.
- 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.
-
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. - Make fast tests the feedback loop. The agent is only as good as the signal it gets.
- Save human review for what matters. People review critical or regulated code closely; agent review takes the first pass on the rest.
- 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.
- 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.mdon 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.

Top comments (0)