Aigile with Claude Code

Install the plugin and skill, then run one feature with the slash commands, being the gates yourself.

The aigile kit referenced below is on the downloads page and at the kit repository; <kit-path> means your local clone of it.

This tutorial takes you from installation to your first sealed feature using the aigile plugin for Claude Code. It uses the same example as the other tutorials: a notes app called Taggr gets a tagging feature.

1. What you need

  • Claude Code (current version), signed in
  • A project repository, ideally fresh or small for the first pass
  • Windows: run shell snippets in Git Bash (ships with Git), or use the PowerShell equivalents noted in the kit’s docs/INSTALL.md

2. Install

From the published kit repository:

/plugin marketplace add goaigile/aigile-kit
/plugin install aigile

For local development of the kit itself, or before it is published:

claude --plugin-dir <kit-path>/adapters/claude-code/aigile

Verify with /help: you should see nine commands under the aigile namespace, /aigile:intent through /aigile:conformance. The plugin also installs the aigile-loop skill, which matters more than the commands: it keeps the method’s rules in force during any work in a repository that contains .aigile/, whether or not you invoked a command. That includes the deviation protocol, the scoped context loading, and the rule that Claude never validates its own work.

3. Set up the durable layer

Create the folders and a first constitution:

mkdir -p .aigile/standards .aigile/domain .aigile/corpus .aigile/features

Write .aigile/constitution.md by hand or ask Claude to draft it from your ground rules; the Taggr example uses five clauses (see the SpecKit tutorial, section 3, for the exact text; the file is identical here). The admission test for every clause: violating it should stop work. Conventions go to .aigile/standards/, business facts to .aigile/domain/, one screen per file.

4. Run the feature

Claude Code has no workflow engine with gates, so you are the gate; the skill and the commands tell you where to stand. The sequence:

Intent.

/aigile:intent A note taker wants to group notes with tags so
related notes can be found together. Success: she tags three
notes and finds them again through the tag. Out of scope:
sharing, tag colors.

The command classifies this FULL weight (new user-facing surface) and interviews you for the primary scenario, made vs deferred decisions, and a sketch reference. It then runs the readiness gate: if you cannot walk your own scenario, it marks the intent NOT READY and refuses to hand it to slicing. That refusal is the feature-slop filter working; answer the open questions or park the idea in .aigile/backlog.md.

Slice.

/aigile:slice tags

Expect vertical slices (S1 skeleton: add one tag to one note and see it; S2 filter by tag; S3 remove a tag; S4 rename and merge), ordered with the skeleton first and risk early. Push back on anything sliced by layer; your correction becomes a corpus norm at the retro, and the next feature’s draft will be better for it.

Spec, build, and the mid-build stop.

/aigile:spec tags 1
/aigile:build tags 1

The spec is one screen, mostly [test] criteria, with Standards: and Domain: lines that scope what the build session loads. During the build, the skill keeps the deviation protocol active: if Claude finds the spec wrong in a way that moves tests, interfaces, or the constitution, it stops and writes a deviation report with options instead of guessing. Decide with:

/aigile:andon tags 1

Your decision’s spec fix ships in the same PR as the code. Details that move nothing observable are logged and work continues.

The skeleton demo. Run the app and drive it yourself: add a tag, look at the note. Then record what you saw:

/aigile:verdict tags 1 skeleton <your feedback in your words>

validated seals the slice. misaligned turns your feedback into spec changes you approve before the session ends. If the demo changed what you want, that is intent evolved and goes to the backlog as a discovery.

The rest. Repeat spec, build, verdict per slice; pull an extra demo for any slice that touched a constitution clause. Close with:

/aigile:verdict tags feature <feedback>
/aigile:retro tags

The retro routes learnings to their artifacts and runs the drift sweep; /aigile:garden prunes the constitution when the cadence fires.

5. What the skill does between commands

Even in plain conversation (“fix this bug”, “refactor that module”), the skill holds the rules: constitution first with version stamp, scoped loading of declared standards and domain files, atomic PRs, the deviation protocol, and the refusal to summarize demos or declare work “the right thing”. If you see Claude drift from these in long sessions, say “aigile” and it will reload the frame.

6. Common early questions

  • Do I need SpecKit too? No. The plugin is complete on its own; the SpecKit adapter exists for teams already living there.
  • Where are the gates? You are the gates. The commands stop and ask; the discipline of actually driving demos is yours, and R21 makes a watched recording count as no demo at all.
  • Team use? Commit .aigile/ to the repository; the skill and commands read the same files for every teammate and every agent.