Setting It Up For Real

So far, Robo and the treehouse have been a story to help the ideas click. Now let's make it real: this is exactly how you'd start using AI-DLC on a real computer, today, for a project as small as Ms. Sharma's library tracker — using AWS's actual open-source AI-DLC rules.

What You Need

Any one of these AI coding tools, already installed: Kiro, Claude Code, Cursor, Amazon Q Developer, Cline, GitHub Copilot, or OpenAI Codex. It genuinely doesn't matter which — AI-DLC isn't a product you buy or install. It's a set of written instructions that any of these tools can read and follow. That's a deliberate design choice, not an accident: the project's own stated principle is "methodology first — users shouldn't need to install anything to get started."

Step 1: Get the AI-DLC Rules

The rules live in a public, open-source repository: github.com/awslabs/aidlc-workflows. From its Releases page, download the latest ai-dlc-rules-v<version>.zip to a folder outside your project (your Downloads folder is fine).

Unzip it. Inside is an aidlc-rules/ folder with two parts:

• aws-aidlc-rules/ — the core workflow: the phases, the stages, the order they run in.
• aws-aidlc-rule-details/ — the detailed instructions each stage reads when it runs (how to ask requirements questions, how to write a code generation plan, and so on).

Step 2: Tell Your Tool About It

Every tool has its own place for project-wide instructions. You copy the same two folders in, just to a different spot depending on which tool you're using:

For example, setting this up for Claude Code on macOS or Linux is just two commands:

cp ~/Downloads/aidlc-rules/aws-aidlc-rules/core-workflow.md ./CLAUDE.md
mkdir -p .aidlc-rule-details
cp -R ~/Downloads/aidlc-rules/aws-aidlc-rule-details/* .aidlc-rule-details/

These files are meant to be committed to your repository, not ignored — they're project configuration, the same as a linter config or a CI file. The whole team gets the same workflow automatically.

A shortcut, if your tool can run commands: instead of downloading and copying folders by hand, you can paste one prompt into Kiro, Claude Code, Cursor, or Antigravity and let the agent do the setup itself — it downloads the latest release, figures out where your specific tool expects its rules file, and writes it. The exact prompt is in the AI-DLC repository's README under "Experimental: AI-Assisted Setup" — worth using once you trust the workflow enough to let it configure itself.

A note if you're using Kiro specifically: Kiro has two chat modes, Vibe and Spec. AI-DLC is designed to run in Vibe mode — Kiro will sometimes nudge you to switch to Spec mode instead; say no to that prompt, since Spec mode is Kiro's own separate planning feature, not AI-DLC.

Step 3: Prepare What You're Building (Optional, But Worth It)

Before you even talk to Robo, two short documents make everything that follows faster and more accurate:

• A Vision Document — what you're building and for whom.
• A Technical Environment Document — what tools, languages, and constraints apply.

Neither has to be long. Here's a genuinely minimal pair for the library tracker:

# Vision: Class Library Loan Tracker

Ms. Sharma's class library tracks borrowed books on paper, and books
keep going missing. We're building a simple app so she can record
loans and returns, and see which books are overdue.

## MVP Features (IN)
- Record a loan (book + student)
- Record a return
- See a list of currently borrowed and overdue books
- Block a loan if the book is already out, or the student already
  has 2 books on loan

## Out of Scope (for now)
- Student self-service / logins
- Fines
- Barcode scanning

## Open Questions
- Do we need to enter the books already out on paper right now,
  or start fresh from today?

# Technical Environment: Class Library Loan Tracker

- Language: Python 3.12
- Package manager: pip
- Framework: none needed — a small script or tiny web app is enough
- Deployment: local only, runs on Ms. Sharma's laptop
- Testing: pytest
- Prohibited: no external database — keep it to a local file. This
  is a two-teacher classroom tool, not a production system, and a
  database is unnecessary complexity for what it needs to do.

- Security: no login needed; not handling sensitive personal data

Every gap you leave blank here just becomes one more question Robo has to ask you later. It's not required — Robo can build all of this up through conversation instead — but a few minutes of writing up front usually saves several rounds of back-and-forth during Requirements Analysis.

What we just wrote is the minimum viable version of each document. For a bigger or longer-lived project, the full versions have more structure worth knowing about: the full Vision Document adds a Target Users table, measurable Success Metrics, and a "Full Scope Vision" section that separates what the product could eventually become from what's actually in this release. The full Technical Environment Document adds sections for allowed/disallowed cloud services, your security compliance framework, CI/CD test gates, and — the single highest-value addition beyond the basics — one or two short example code files showing your team's actual patterns, so Robo follows your conventions instead of inventing its own. None of this was necessary for a two-teacher classroom tool; it matters a great deal once real users, real money, or a whole team are involved.

Step 4: Say the Magic Words

With the rules installed (and, ideally, those two documents ready), starting is one sentence, typed into your tool's chat:

Using AI-DLC, I want to build a simple app to help Ms. Sharma's class
library track borrowed books. Please read vision.md and
technical-environment.md, then begin the AI-DLC workflow.

That phrase — "Using AI-DLC, ..." — is the entire kickoff. From here, everything you saw in Lessons 2 through 4 starts happening for real: Robo detects this is a greenfield project, opens a requirements question file, and works forward through whichever stages actually apply.

Step 5: Know What You're Looking At

Once it's running, a folder appears at the root of your project that you haven't manually created:

library-loan-tracker/
├── aidlc-docs/            <- everything Robo writes, documentation only
│   ├── aidlc-state.md
│   ├── audit.md
│   ├── inception/
│   ├── construction/
│   └── operations/
├── src/                   <- your actual application code
└── tests/

This is exactly the structure we've been walking through since Lesson 2 — now you know precisely where it comes from and how to get it running yourself.

If Something Doesn't Load

A short table of the problems people actually run into:

Most tools also have a way to directly confirm what's loaded — Claude Code's /config, Kiro's /context show, Copilot's /instructions — worth checking the first time, so you're not guessing.

What Belongs in Git

Commit the rules files and the rule details — they're project configuration everyone on the team should share:

# Commit these
CLAUDE.md
AGENTS.md
.kiro/steering/
.kiro/aws-aidlc-rule-details/
.cursor/rules/
.clinerules/
.github/copilot-instructions.md
.aidlc-rule-details/

aidlc-docs/ itself — everything Robo generates — should be committed too, for exactly the reasons Lesson 5 covered: it's the record of why the project looks the way it does.

A Few Honest Tenets (Straight From AWS)

The project publishes the principles it holds itself to. A few worth knowing as you use it:

• Methodology first. It's a way of working, not a tool you're locked into.
• Agnostic. Works with any IDE, any agent, any model — no vendor lock-in by design.
• Human in the loop. Critical decisions require your explicit confirmation. The agent proposes; the human approves.
• Reproducible. The rules are written to be explicit enough that different AI models produce similar outcomes, not wildly different ones.

What's Next

Setup is done, and the workflow has started. The next lesson covers the day-to-day habits that make working with it smooth — how to ask a question without accidentally triggering a document rewrite, when to reset your chat, and the one rule experienced teams say matters more than any other.

Continue to: Working With It, Day to Day