Claude Code is powerful, but without structure it drifts - forgets context between sessions, silently changes approach when something fails, reviews its own code with no outside perspective, and loses track of what was decided and why.

LETS fix this. You get a team of 14 specialized AI agents, a structured development workflow, and a PR review system that posts inline comments directly to GitHub - all from the terminal. Every session has a task. Every commit links to it. Context survives across sessions and conversation compaction.

Why LETS?

You don't just chat with AI. You run a process — /lets:* commands and 14 expert agents cover the whole development cycle, every change is reviewed by the right specialists, and every decision is made deliberately, with you in the loop.

• A complete workflow, not a chat box. One loop from start to ship — restore context and pick a task, plan the work, build it, review it, open a PR, close the task. The plugin keeps Claude on the rails the whole way; nothing falls through the cracks.
• Plan before you build. Pulse and clean up the backlog, design the architecture with real codebase exploration and expert review, then execute step by step behind approval gates. Choices are made on purpose, not improvised.
• Every change reviewed by the right experts. 14 specialized agents select themselves based on what changed - security for auth code, database for migrations, architect for structure. Findings come tiered by severity, so you act on what matters. Plus an actor agent — point it at a senior iOS dev's profile, a UX designer's, anyone — and get their take.
• You decide, always. Commit, push, PR, merge - every state-changing step waits for your "go". The AI proposes and explains its reasoning; it never silently switches approach. Transparency by design.
• Context that survives. Tasks, decisions, and discovery notes live in beads and outlast conversation compaction and new sessions - pick up exactly where you left off.
• Built for teams. Shared task database via Dolt, Agent Teams that implement multiple tasks in parallel (each in its own worktree, plan approved by the lead), and worktrees for hands-on parallel sessions.
• GitHub-native PR review. Agents analyze the PR, you discuss findings, they post inline comments to the exact lines, follow up on fixes, approve or request changes - without leaving the terminal.
• Built on the latest Claude Code features. Ultrathink for deep analysis, interactive UI for decisions, native plan mode for execution.

LETS statusline and /lets:review command in action

🚀 Quick Start

LETS is two pieces: a small lets CLI on your $PATH, and the plugin inside Claude Code. Install both, then initialize your project.

1. Install the CLI

macOS / Linux:

curl -fsSL https://raw.githubusercontent.com/restarter/lets-workflow/main/scripts/install.sh | bash

You also need beads (bd) on $PATH — LETS uses it for task tracking. You don't have to learn beads: the plugin drives bd entirely for you, so just get it installed. Its install guide has all the options; the quick one-liner:

curl -fsSL https://raw.githubusercontent.com/steveyegge/beads/main/scripts/install.sh | bash

Manual download, Windows, source builds, troubleshooting → docs/installation.md.

2. Install the plugin

In Claude Code:

/plugin marketplace add restarter/lets-workflow
/plugin install lets

Install scope: Claude Code will ask where to install — all three options work:

• "Install for all collaborators on this repository" (project scope) — recommended for shared repos; the choice lands in .claude/settings.json, so teammates inherit lets without re-installing.
• "Install for you, in this repo only" (local scope) — fine for a solo or throwaway project; not committed.
• "Install for yourself everywhere" (user scope) — one install for all your projects. After installing, /lets:init in any project offers lets init --user: global workflow rules land in ~/.claude/rules/lets-rules.md and your personal defaults (language, launcher) in ~/.lets/.env — every project gets LETS without per-project setup. Project rules override global on conflict. Details, precedence, and the opt-out limitation: docs/installation.md.

Stay current (do this once): in /plugin → Marketplaces → lets-workflow, Enable auto-update — the plugin then tracks every release on its own. Staying current then collapses to a single self-driving loop: run /lets:update, do the one thing it says, re-run until it prints ✓ Everything on vX.Y.Z — each run advances one step (binary → plugin → reload → done), the binary step offers to run the installer in-session, and rules never sync to a plugin that's still behind.

(Or install from a local clone — git clone https://github.com/restarter/lets-workflow, then /plugin marketplace add ./lets-workflow and /plugin install lets — handy for hacking on the plugin: edit the clone, then /reload-plugins to pick up your changes.)

3. Initialize your project

cd your-project
claude

Then, inside the Claude Code session:

/lets:init

/lets:init creates .lets/ (config + statusline) and runs bd init if beads is installed. From there, start each work session with /lets:start — the full loop is in Using LETS below.

📖 Commands

→ Full docs: docs/commands.md

Session & Task

Planning & Execution

Review & Analysis

Init & Update

🤖 Expert Agents

→ Full docs: docs/agents.md

LETS ships 14 specialized agents. You never pick them by hand — the commands that use agents (/lets:review, /lets:opinion, /lets:ask, /lets:plan, /lets:backlog, /lets:research, /lets:team) look at what you're doing and bring in only the ones that fit.

Dynamic selection. Each command analyzes the change (or the plan, or the question) and selects only the experts that matter — touch auth code and security, backend, and architect join; a pure docs update gets docs + compliance and nothing else; a full-stack feature can pull in up to 12, each focused on its domain. (compliance and docs always join a review. For plan reviews, the picks come from signals in the plan text — migrations, API endpoints, Docker configs, ….)

Tiered findings. Every finding is [BLOCKER] (must fix), [SUGGESTION] (should fix), or [NIT] (nice to have). Agents are tuned to skip the obvious and surface what actually matters — signal, not a wall of nitpicks.

Modes. The same agent behaves differently depending on context — review for code review, opinion for a technical decision, plan for evaluating an architecture, brainstorm for ideation, ask for a direct question. Same expertise, different lens.

Read-only by default. Agents analyze; they never touch your code. The one exception is implementer, which gets write access for parallel implementation via /lets:team (in an isolated worktree, behind your plan approval).

The actor agent. Give actor a personality — a URL or a local file — and it adopts that persona, then works with LETS's structured output. A senior iOS dev on your Swift code, a UX designer on your components, anyone — point it at their writeup and get their take. It's never auto-selected; you confirm each personality before it's loaded.

🔧 Using LETS

→ Full docs: docs/workflow.md

A LETS session runs a loop: start, work, commit, finish.

/lets:start ─── choose how to work ─── /lets:commit ─── /lets:done ─── /lets:end

Start - /lets:start restores context from the previous session, shows available tasks, and creates a feature branch. Context survives conversation compaction via beads task comments.

Choose how to work - depending on the task, you pick the approach:

┌─ You write code yourself ─────────────────────────────────────────────────┐
│  Write code with Claude. Use helpers along the way:                       │
│  /lets:opinion   Technical decision with expert agents                    │
│  /lets:ask       Quick question to a single expert                        │
│  /lets:check     Quick sanity check (6 perspectives, ~30s)                │
│  /lets:review    Full multi-agent code review (~2-3 min)                  │
│  /lets:research  Web-sourced cited answer to a question                   │
│                                                                           │
├─ You plan, Claude builds ─────────────────────────────────────────────────┤
│  /lets:backlog     Backlog review (multi-agent) + cleanup triage          │
│  /lets:plan        Design how to build it - codebase exploration, arch    │
│  /lets:execute     Claude implements the plan with your approval gates    │
│                                                                           │
├─ Agents work in parallel ─────────────────────────────────────────────────┤
│  /lets:team        Spawn agents that implement multiple tasks at once     │
│  /lets:worktree    Open parallel sessions in separate terminals           │
└───────────────────────────────────────────────────────────────────────────┘

Commit - /lets:commit reviews changes and creates a conventional commit (feat:, fix:, docs:, …) linked to the active task.

Finish - /lets:done creates a PR on GitHub or Bitbucket (or merges locally). /lets:end saves a session snapshot so the next conversation picks up where you left off.

Plan, then build

→ Full docs: docs/plan-execute.md

Think → Design → Build

Backlog (/lets:backlog) - manage the task backlog in three modes: Review backlog (agents analyze your task list, find patterns, suggest priorities), --fast (a quick no-agent pulse - fast context scan, then a direct conversation), and Cleanup (find stale tasks, broken dependencies, forgotten work). /lets:backlog review, /lets:backlog --fast, and /lets:backlog cleanup skip the menu. /lets:backlog review --workflow runs the Review fan-out off-context.

Plan (/lets:plan) - codebase exploration with dynamically-scaled explorer agents, then architecture design with expert evaluation. Small project? One explorer. Large monorepo? Up to 10, each mapping a different area. Want a quick talk-through instead? /lets:plan --fast skips the subagent phases and plans collaboratively in-session.

Execute (/lets:execute) - implements the plan step by step in native plan mode. You approve each step before Claude proceeds. No surprises.

Research (/lets:research) - unlike /lets:opinion (project-grounded judgment, no web) or /lets:ask (a quick model-knowledge consult), this answers an external or technical question with a CITED synthesis: it searches the web, fetches the best sources, and a cross-check pass flags single-source, contradicted, or stale claims before presenting. The deliverable is a sourced answer with a Sources list and an as-of date. --workflow runs it off-context; --project grounds findings against this repo.

Code review

→ Full docs: docs/code-review.md

Three levels of review, from 30-second sanity check to full PR lifecycle:

GitHub PR Review Lifecycle (/lets:github-pr)

This is where LETS shines. Instead of reviewing PRs in a browser, you do it from the terminal with expert agents. /lets:github-pr is GitHub-only. Bitbucket PRs review with /lets:review (fetch, diff, discussion, summary comment) and finish with /lets:done:

/lets:github-pr https://github.com/owner/repo/pull/42

1. Analyze - agents review the PR based on what actually changed (security agent for auth code, database for migrations, etc.)
2. Discuss - you see each finding with code context, decide what to post: inline comment, summary, or drop
3. Post - batch-posts inline comments to the exact lines on GitHub, with a review summary
4. Follow up - after the author pushes fixes, /lets:github-pr --follow-up checks each finding: fixed, not fixed, or needs discussion
5. Approve - /lets:github-pr --approve when ready, or request changes

Authors can respond with /lets:github-pr --respond - triage comments, auto-fix mechanical issues, post replies.

Working in parallel

→ Full docs: docs/parallel-work.md

Two ways to work on multiple tasks at once:

Agent Teams (autonomous) — spawn multiple agents that work in parallel, each in an isolated worktree:

/lets:team run    # select tasks, agents start working

Each teammate gets one task, creates a plan, waits for your approval, then implements. Commits are cherry-picked back. Dynamic teammate count - the system scales based on how many tasks you select.

Worktrees (interactive) — work on multiple tasks yourself in separate terminals:

/lets:worktree create auth-feature    # Terminal 1 (main repo)
cd .worktrees/auth-feature && claude  # Terminal 2 - start new session

Each worktree gets its own branch, shares the task database and config via symlinks. Full LETS workflow in each terminal.

On Linux or macOS with tmux installed, set LETS_LAUNCHER=tmux (or run /lets:init and pick tmux) and /lets:worktree create opens the session in a tmux window/session automatically — no second terminal. On macOS, cmux is a GUI alternative (LETS_LAUNCHER=cmux). Both stay optional: without the launcher's binary (or on Windows) it falls back to the cd … && claude command above.

LETS Help Boxes

After key actions, Claude shows a contextual help box with the most likely next steps, so you always know what to do next:

┌─ LETS ─────────────────────────┐
│  Review?  /lets:review         │
│  Commit?  /lets:commit         │
└────────────────────────────────┘

📋 Task Integration

→ Full docs: docs/tasks.md

LETS uses beads for persistent task tracking that survives conversation compaction:

• Every session starts by selecting a task, every commit links to it
• Discovery notes and decisions are saved as task comments - they survive context window limits
• Task dependencies and blocking tracked - /lets:status shows what's ready to work on
• Multi-developer: shared task database via Dolt remotes - everyone sees the same backlog

⚙️ Configuration

→ Full docs: docs/configuration.md

After /lets:init, edit .lets/.env:

# Default response language — write the English name, like every value here (English, Ukrainian, Russian, Japanese, ...)
LETS_LANGUAGE=English

# Target branch for merges and PR base
LETS_MERGE_BRANCH=main

# PR flow: github | bitbucket | local
LETS_PR_FLOW=github

# Task tracker adapter: beads | none  (selects .claude/rules/tracker-<name>.md; see docs/trackers.md)
LETS_TRACKER=beads

All plugin-generated files live under .lets/ (gitignored); interactive worktrees under .worktrees/.

Statusline

/lets:init wires the LETS statusline into .claude/settings.json (lets statusline). By default it draws a bordered multi-line box — identity (brand, folder/worktree, branch, diff, PR), budget (model + effort + usage), task, and a rotating tip line — width-responsive (Full ≥72 cols, Compact below), universal text glyphs (no Nerd Font or emoji needed), light/dark palettes.

Flags (set in settings.json's command):

To make a choice stick without hand-editing settings, run /lets:statusline (interactive) or lets statusline config --light … — it persists the flags to your personal, gitignored .claude/settings.local.json (not the shared settings.json, so it won't force your palette on collaborators). Restart Claude Code to apply.

{
  "statusLine": {
    "type": "command",
    "command": "lets statusline --light"
  }
}

Add --light for light-background terminals (default palette is dark). Full details — line anatomy, width tiers, worktree behavior — in docs/statusline.md.

📦 Dependencies

📚 Documentation

The README is the tour; docs/ is the manual.

Building on the plugin itself? See CONTRIBUTING.md and CLAUDE.md.

License

MIT