Install the Plan & Build plugin.

Open the project you want to change in Claude Code. The plugin reads this project during setup and writes plans and specs into it.

Everything runs inside Claude Code under your existing Claude subscription. Use Plan & Build for work too large to describe in one prompt.

01/Before you install

Accept the GitHub invitation from your email. It gives your GitHub account read access to the private plugin repository and nothing else.

Without access, installation stops partway without a useful message. If the email is missing, open your GitHub notifications.

The quality gates also need a small runner that the plugin does not include. The doctor installs it with your consent during setup.

02/Install and set up

Run these three steps and four commands in order.

1. Install the plugin

The first command registers the Tenkr marketplace. The second downloads and installs Plan & Build from the private repository.

The @tenkr-plugin-marketplace suffix is required. It identifies the plugin's marketplace.

// 1. Register the Tenkr marketplace
/plugin marketplace add TenkrAS/tenkr-plugin-marketplace

// 2. Install the plugin (the @marketplace suffix is required)
/plugin install plan-and-build@tenkr-plugin-marketplace

2. Set up the current project

Setup reads your project and writes one note to plugin memory. It changes nothing else.

It scans your existing setup, notes overlaps, and records your choices. Expect a question or two. Nothing in your project is edited, moved, or deleted.

/plan-and-build:setup

3. Install the quality-gate toolchain

The doctor detects what is already installed and asks before installing anything. It installs into your user space, not system-wide.

The installed runner is named uv. It includes its own Python and fetches required checkers on demand. The doctor is safe to re-run.

/plan-and-build:doctor

03/Run your first task

Use the next real piece of work on your list. Real constraints give the research round enough detail to produce a specific plan.

1. Research and plan the work

Describe the task as you would to a colleague joining the project. Include constraints that usually feel too obvious to mention.

The command researches the task across several rounds. It then writes a complete implementation plan to plans/.

/plan-and-build:pre-plan

Read the plan before continuing. This is the cheapest point to correct a wrong answer.

The plan must match your project. Check that:

• The steps follow an order you would choose.
• The breakdown matches the project's actual structure.
• Every referenced part of the codebase exists.

A plan that fits any similar project is too generic. Run /plan-and-build:pre-plan again with more context. Start with the constraint you assumed was obvious.

2. Create the task spec

Once the plan holds up, convert it into a verifiable, owner-assigned task spec.

This command writes the spec to specs/. It only plans and never builds. The new spec is the only project file it changes.

/plan-and-build:plan-w-team

3. Build the work

This command executes the spec. It deploys a builder for each task and verifies each result with the validator.

Completion requires evidence. Tasks that cannot show their work remain open.

/plan-and-build:build

The plan and spec remain on disk. You can start from the artifact you need next time.

04/Daily workflow

For a new task, run these three commands in order.

// 1. Research the task, then write the plan to plans/
/plan-and-build:pre-plan

// 2. Break the plan into a task spec in specs/
/plan-and-build:plan-w-team

// 3. Execute the spec, gated on evidence
/plan-and-build:build

Each command reads the previous command's output:

Stop after /plan-and-build:plan-w-team when you only need the task list.

The plugin creates plans/ and specs/ when first needed. Neither directory assumes a particular repository layout.

The files are yours to edit. You can edit a spec by hand if its structure remains valid. A structure validator checks it before the build starts.

Two commands sit outside the daily pipeline:

• /plan-and-build:setup records the setup for one project.
• /plan-and-build:doctor checks the toolchain and is safe to re-run. Run it on each new machine before trusting the gates.

05/How completion is checked

Plan & Build researches work before building it. You describe the task once. It produces a plan, a task spec, and code that must prove it works.

The build uses two agents with different jobs:

• The builder handles one task at a time and reports evidence for its work.
• The validator checks that evidence against the task's acceptance criteria. It is read-only and cannot fix failures to make its checks pass.

An evidence gate blocks completion without proof another reader can check. A builder's claim alone cannot close a task.

The evidence gate is one of six governance hooks. The others inject methodology into agents, validate spec structure, and run Python lint and type checks.

06/Troubleshooting

07/Files, privacy, and updates

Everything runs on your machine under your Claude subscription. Tenkr never sees your project, files, or prompts.

The plugin adds no account and requires no second key. Plans and specs are ordinary files in your project directory. You can read, delete, or commit them.

Nothing leaves your machine unless you push it somewhere yourself.

Your one-time purchase includes lifetime updates through the same install command.

Plan & Build also works with the Core Methodology plugin. When installed, its disciplines include validation-first execution, verification before completion, and deliverable review.

Without Core Methodology, Plan & Build skips those steps and continues its pipeline. Neither plugin requires the other.