v6.1 · released 3 October 2026

Human in the lead, not just in the loop.

Give your agents a sprint. They report back for your approval.

SDLC Studio runs your coding agent as a lean Scrum team. You approve a one-sentence goal. It builds each unit test-first, has each one reviewed by an agent that did not write it, and hands you one page to sign. Every run feeds the next.

Get startedHow the factory works

  • v6.1.0
  • Supported by Anthropic through Claude for Open Source. Sponsorship, not endorsement.
Agree the goal. Sign the page.The factory runs in between.

You

Agree

You approve the goal and the plan once, and that approval opens the run; after that it does not stop to ask.

sprint.py plan --write

  1. 01 / Plan

    Checks each unit is scoped and sized, orders the batch against the agreed goal, and forecasts what it will cost.

    sprint.py plan

  2. 02 / Build

    Builds each unit test-first and runs its acceptance criteria.

    verify_ac.py run

  3. 03 / Review

    One reviewer who did not write the unit judges it, in at most two rounds.

    critic.py brief

  4. 04 / Close

    Closes the run in one pass and files a one-page report of what shipped and what did not.

    sprint.py close

  5. 05 / Learn

    Turns what went wrong into failure classes the next plan and briefs carry.

    retro.py extract

Return belt Learn back to Plan

You

Sign

You read one page and sign it once, which moves each unit to Done or Fixed; the sign command refuses anyone who wrote or reviewed a unit.

sprint.py sign

One install, every agent

The installer puts the same skill where each of these reads its skills.

What runs by itself, and what is yours

Planning runs by itself; approving the plan is yours. Between that approval and your signature, every step runs unattended, and each names the command that does it, so you can read it or run it yourself.

  1. YouAgreeyourssprint.py plan --write
  2. 01Planruns by itselfsprint.py plan
  3. 02Buildruns by itselfverify_ac.py run
  4. 03Reviewruns by itselfcritic.py brief
  5. 04Closeruns by itselfsprint.py close
  6. 05Learnruns by itselfretro.py extract
  7. YouSignyourssprint.py sign

What makes the loop

  • One sprint goal

    in 6.0

    A goal of 20 words or fewer, traced to an outcome or a persona, approved once with the plan.

    sprint.py planRead

  • One independent reviewer

    in 6.0

    Each unit is judged by one reviewer who did not write it, briefed by the shipped tool, in at most two rounds; a unit still rejected at the cap is carried as a bug.

    critic.py briefRead

  • The close in one pass

    in 6.0

    The close runs every step once and files a one-page report that states each known issue rather than being withheld over one.

    sprint.py closeRead

  • One signature

    in 6.0

    You sign the run once, after reading the report; a principal who authored or reviewed a unit in it is refused.

    sprint.py signRead

  • Stopping a run

    in 6.0

    A run can be stopped; while a unit is unanswered the stop is refused unless forced, and a forced stop names each unit it waived.

    sprint.py stopRead

Who answers the questions

A run raises questions. A question in a seat's lens is ruled by that seat, citing the rulings before it. A question only you can answer sets its unit aside, and the run puts all of them to you at once.

The release run, RPT0011, had 0 questions ruled by a seat and 8 ruled by the operator. The line runs by itself between your two touchpoints; it does not run without you.

Questions ruled, per run
RunBy a seatBy the operator
RPT000640
RPT000720
RPT000830
RPT000940
RPT001020
RPT001108

  • Persona rulings

    in 6.0

    A question in a seat's lens is ruled by that seat, citing any earlier ruling on the subject, so the run does not wait for you.

    decisions.py ruleRead

  • Your questions, asked together

    in 6.0

    A question only you can answer sets its unit aside without halting the batch, and every such question is put to you at once.

    sprint.py decision deferRead

How it learns

Each plan re-measures the cost per point from the newest runs, and the learn step records what went wrong as a failure class, whose rule the next plan and every review brief carry.

The last three runs each spent about half of what was forecast, so the forecast now tends to run high; you can set the rate by hand. A class being recorded is not proof it stops recurring: a class that repeats twice is filed as a change request to fix its failing path.

Tokens spent against the forecast
RunSpent against forecast
RPT00061.14x
RPT00070.5x
RPT00081.03x
RPT00090.51x
RPT00100.53x
RPT00110.5x

  • A forecast that follows the newest runs

    in 6.0

    The cost per point is re-measured from the newest runs at every plan, and you can set it by hand.

    sprint.py planRead

  • Failure classes

    in 6.0

    What went wrong in a run is recorded as a failure class, and its rule is carried into the next plan and each review brief.

    lessons.py classesRead

  • A repeating class graduates

    in 6.0

    A class that repeats twice after it was recorded files one change request to fix its failing path, and reads graduating.

    sprint.py closeRead

  • A class that has graduated

    in 6.1

    Once the change request a graduating class filed ships, the close marks the class graduated, with no hand edit; a class whose request was rejected is retired instead, so a later repeat revives it.

    sprint.py closeRead

Measured runs

The six v6 runs, each closed by the tool and signed by the operator. Hours are wall-clock, so waiting counts; the token ratio is tokens spent against the forecast.

  1. RPT0006Judged achieved

    A sprint runs start to finish on its own, learns from itself, and hands you one page.
    Points
    58
    Hours open
    8.7h
    Token ratio
    1.14x

  2. RPT0007Judged partial

    Commits clear in about a minute, and the sprint learns from repeated mistakes without being told.
    Points
    42
    Hours open
    5.4h
    Token ratio
    0.5x

  3. RPT0008Judged partial

    A commit clears in ninety seconds, and every commit lane left standing shows what it caught.
    Points
    32
    Hours open
    7.2h
    Token ratio
    1.03x

  4. RPT0009Judged partial

    Maya's units are reviewed once against their files' history, and the review paperwork nobody reads is deleted.
    Points
    111
    Hours open
    7.0h
    Token ratio
    0.51x

  5. RPT0010Judged achieved

    Maya runs the lean loop on a fresh v6 project, and the release candidate ships.
    Points
    102
    Hours open
    27.3h
    Token ratio
    0.53x

  6. RPT0011Judged achieved

    v6.0.0 ships: Maya and Jonah install, upgrade and learn it from docs and notes that match the code.
    Points
    131
    Hours open
    29.5h
    Token ratio
    0.5x

The v5 baseline

v5 review, 23 September 2026

A v5-era run stood open for 14.5 to 59.6 hours. Of the last 116 v5 sprint units, 82% built or repaired the sprint, review and gate machinery rather than the product. The token forecast missed by 4.07x on geometric mean.

The evals

On the candidate and the release

Eval 09, a lean sprint: Pass, for one fresh agent working from the docs alone, its plan pre-approved.

Eval 06, the independence gate: Fail on the release candidate, then 11 of 11 behaviours on the final skill.

Shipped open

Known issues at 6.1.0

2 defects ship open, each listed by id with its severity. Read the known issues.

Every run in fullHow we know it works

Start on code you already have

Point it at a repository that has never seen SDLC Studio. Nothing needs setting up first, and nothing is written to your code. If the findings are not worth having, stop there.

The brownfield walkthroughHow the audit verifies

In your agent, in the repository
/sdlc-studio audit --profile repo
Hunts
Architecture, code quality and defensive security.
Checks
Each candidate goes to a panel briefed to refute it.
Files
Only the survivors, as bugs and change requests with their own ids.
Security
Remediation only: where it is, the weakness, its realistic impact and a concrete fix, with no proof-of-concept payload. A committed secret is reported by where it is, with the value left in place.

Install

One command, pinned to v6.1.0. It checks the download against the release's published checksum before unpacking it, and refuses when that checksum is missing or does not match.

Install v6.1.0
curl -fsSL https://raw.githubusercontent.com/DarrenBenson/sdlc-studio/main/install.sh \
  | SDLC_STUDIO_REQUIRE_CHECKSUM=1 bash -s -- --version v6.1.0

Coming from 6.0? Install, then run the same two migrate steps in each project. What 6.1 retires.

Coming from v5? Install, then run migrate in each project for a dry run, and migrate --apply to carry it across. What v6 removes and keeps.

Then, in a 6.0 or v5 project
# a dry run: what it would change
/sdlc-studio migrate
# carry the project across
/sdlc-studio migrate --apply

Get startedRelease notes