Greenfield walkthrough - build a task-management app

Let us build a real thing from nothing: TaskFlow, a small task-management web app where a signed-in user can create, list, complete and delete their own tasks. This page follows it from an empty repository to a first increment that is built, proven and independently reviewed.

You will spend most of it in plain language. Every step has an explicit command shown as the explicit form, but you do not need to type them.

Part 1 - from empty repo to a first plan, in one command

In your empty taskflow/ repo:

/sdlc-studio init guided

Guided init sees no code and classifies the project greenfield, then walks the seven stages. Review each draft, then say “looks good, continue” (the explicit form is init guided --confirm).

1. agents - it writes AGENTS.md and CLAUDE.md so every AI tool you point at TaskFlow follows the same rules.

2. prd - an interview: what is TaskFlow, who is it for, what must it do? You describe the features; it writes sdlc-studio/prd.md - a Feature Inventory (create / list / complete / delete a task, sign-in), functional and non-functional requirements (a task list loads in under 300ms), and the open questions.

3. trd - from that PRD it drafts sdlc-studio/trd.md: project type Web App, a recommended stack with real rationale, the task and user data models, the REST endpoints, and any decision worth an ADR.

4. tsd - it drafts sdlc-studio/tsd.md: the test strategy - unit ≥ 90%, the delete-a-task path 100% covered end to end, and the quality gates that will block a build.

5. personas - it grows your team and the people TaskFlow is for:

   /sdlc-studio persona generate --team          # Lena (Product), Dani (Eng), Sam (QA), grown from TaskFlow
   /sdlc-studio persona generate --from-prd       # Priya, the busy team lead who lives in her task list

6. decompose - the PRD becomes epics and sized stories, each naming the persona it serves:

   /sdlc-studio epic
   /sdlc-studio story --epic EP0001

7. plan - it grooms the backlog and plans your first sprint. This is where guided init ends - you are standing exactly where delivery begins.

   /sdlc-studio reconcile && /sdlc-studio validate   # a clean, drift-free backlog
   /sdlc-studio sprint plan                          # a sized, sequenced first sprint

Everything so far is plain Markdown under sdlc-studio/ that you read and edit - prd.md, trd.md, tsd.md, epics/, stories/, personas/.

Caution

Cold-start reality. A sprint’s Done gate runs your tests, and an empty repo has none yet. So you build the foundation epic (the app skeleton, the test harness, sign-in) by hand up to a green gate first. Only then do you hand the following epics to the sprint loop. The tool will not pretend an empty repo has a runnable gate.

Part 2 - build one increment under the discipline

Now the foundation is green and “a user can delete their own task” is a Ready story (US0007).

1. You say: “Build the delete-a-task story.”

   Dani, your Engineering seat, writes the failing test first, implements the endpoint and the UI action, and runs the story’s acceptance criteria. The story reaches Done only when they pass.

   verify_ac run --id US0007   ->   ac=2 pass=2 fail=0 manual=0

   The explicit form: story implement --story US0007, then reconcile --verify --story US0007

2. You say: “Review it.”

   A fresh reviewer that did not write the code - Sam’s review render - runs an adversarial pass: does it truly refuse deleting someone else’s task? It files what it finds as evidence. Then you, or a delegate who is not the author, sign it off.

   The explicit form: critic evidence … then critic signoff --principal "you"

3. You say: “Close the sprint.”

   The close records the sign-off, transitions the stories to Done, derives the epic and any parent request to Complete, validates the retro and lifts its lessons, and runs the gate.

   The explicit form: sprint close --retro RETRO0001 --apply-signoff --principal "you"

Note

Want it hands-off for the rest? You say “take this epic to done” and the goal-driven autosprint drives the whole batch - build, verify, review - and closes with a reconcile and review. You set the goal and the acceptance criteria; the team drives the proven lifecycle to it.

What you have

TaskFlow’s delete feature, shipped: every story Done against passing criteria, a review record naming a reviewer who was not the author, a retro with its lessons, and the request marked Complete - all as plain files under sdlc-studio/, true to the code that actually exists. You got here by describing what you wanted; the discipline held underneath.

Where to next

• Brownfield walkthrough - the same journey starting from code you already have.
• The specification layer - the PRD, TRD and TSD you just wrote, in detail.
• Sprint planning & autosprint - how the plan and the hands-off loop work.