rstack

"When I stopped writing, I noticed that everything was realer now. I can't speak about nothing but what's real because I can't write nothing down." — Lil Wayne (VH1 Behind the Music, 2009)

When I stopped writing code line by line and started directing AI agents, something changed. The code got more real. Not because I cared less — because I could finally focus on what mattered: architecture, correctness, user impact. The scaffolding became automated. The judgment stayed human.

I'm Russell Moss. I build internal analytics tools — a Next.js/TypeScript/BigQuery dashboard used by 35+ people whose business decisions depend on accurate numbers. Wrong data means wrong decisions. Silent failures mean lost revenue.

I was shipping fast with AI agents. Then a drill-down modal silently dropped records. A forecast calculation was wrong for three weeks. An export broke a downstream Sheets workflow that ops relied on daily. Every bug had the same root cause: the agent didn't know what it didn't know.

The AI wasn't dumb. It was stateless. Every session started fresh. Every feature forgot the lessons from the last one. Every review missed the patterns that a human teammate would have caught on day two.

rstack is my fix. It layers decision history, documentation drift detection, schema-aware verification, and adversarial cross-LLM review on top of the raw coding agent. Each feature you build makes the next one cheaper because precedent, patterns, and verified schema accumulate.

It includes all of gstack's MIT-licensed sprint-velocity tooling — browser automation, design pipeline, sprint commands, safety guardrails — because speed matters. But speed without correctness is just shipping bugs faster.

rstack = gstack's speed + production-grade correctness infrastructure.

The core thesis

Agentic development fails from statelessness, not model capability.

Session 1: Agent builds feature A. Makes 4 architectural decisions. Ships.
Session 2: Agent builds feature B. Has no memory of feature A.
           Re-discovers the same patterns. Makes contradictory decisions.
           Breaks feature A's assumptions. Ships.
Session 3: Bug report. Agent has no idea why the code looks the way it does.

This is the cycle rstack breaks. Here's what it adds:

┌─────────────────────────────────────────────────────────────┐
│                     rstack infrastructure                    │
│                                                             │
│  ┌──────────────┐  ┌──────────────┐  ┌───────────────────┐ │
│  │ context-     │  │ agent-guard  │  │ council-of-       │ │
│  │ ledger       │  │              │  │ models-mcp        │ │
│  │              │  │ Documentation│  │                   │ │
│  │ Decision     │  │ drift        │  │ Cross-LLM         │ │
│  │ history +    │  │ detection    │  │ adversarial       │ │
│  │ queryable    │  │              │  │ review            │ │
│  │ precedent    │  │ Auto-sync    │  │                   │ │
│  │              │  │ after every  │  │ OpenAI + Gemini   │ │
│  │ Every        │  │ pipeline     │  │ check your plan   │ │
│  │ decision     │  │              │  │ independently     │ │
│  │ compounds    │  │ Docs never   │  │                   │ │
│  │              │  │ go stale     │  │ 2 models catch    │ │
│  │              │  │              │  │ what 1 misses     │ │
│  └──────────────┘  └──────────────┘  └───────────────────┘ │
│                                                             │
│  ┌──────────────────────────────────────────────────────┐   │
│  │ schema-context-mcp (optional)                        │   │
│  │ Live database queries · Field verification           │   │
│  │ Population rates · Edge case detection               │   │
│  └──────────────────────────────────────────────────────┘   │
│                                                             │
├─────────────────────────────────────────────────────────────┤
│                   gstack velocity layer                      │
│  Browser automation · Design pipeline · Sprint commands     │
│  Safety guardrails · QA · Code review · Ship · Deploy       │
│  23 specialist skills · All MIT licensed                    │
└─────────────────────────────────────────────────────────────┘

The bottom layer ships fast. The top layer ships correct. Together, they compound.

Who this is for

• Solo developers building production apps — where "it works on my machine" isn't enough because real users depend on your data
• Small teams (2-5) who want structured AI-assisted development without the chaos of raw agent sessions
• Technical founders who still ship code — you're running the company AND building the product
• Engineers working on data-sensitive applications — financial dashboards, analytics platforms, internal tools where correctness matters as much as velocity

Not just Next.js/TypeScript. rstack detects and supports Node.js, Python, Rust, Go, and Ruby projects. The setup wizard tailors everything to your stack.

Quick start

# Install globally
npm install -g @mossrussell/rstack

# Set up a project
cd your-project
rstack init

# See available commands
/help

# Build your first feature
/auto-feature "Add user authentication with email/password"

That's it. rstack init takes ~2 minutes: detects your stack, asks about your project, generates tailored agents and commands, initializes decision history and documentation tracking, and validates everything.

See it work

You:    I need to add AUM forecasting to the advisor dashboard.
You:    /auto-feature Add AUM forecasting with historical trends

rstack: [Launches 3 parallel exploration agents]

        code-inspector → traces the full code path:
          src/types/dashboard.ts:42 — AUM interface
          src/lib/queries/aum.ts:15 — existing aggregation
          src/components/dashboard/AumCard.tsx:8 — display component
          src/app/api/dashboard/aum/route.ts:1 — API endpoint

        data-verifier → checks the schema:
          ✓ aum_total field exists, 98.7% populated
          ✓ advisor_join_date__c exists, case-sensitive
          ⚠ forecast_date has 12% NULL rate — needs COALESCE

        pattern-finder → maps existing patterns:
          ✓ Date handling: extractDate() wrapper, not raw casts
          ✓ Dedup: is_sqo_unique flag, not is_sqo
          ⚠ Drift: AumCard uses toString(), ForecastCard uses raw string

        [Synthesizes into exploration-results.md]
        [Builds phased implementation guide with validation gates]

rstack: Sending to council for adversarial review...

        OpenAI Codex: "Phase 4 references forecastQuery() but it's not
          defined until Phase 5. Reorder. Also: the NULL rate on
          forecast_date means the COALESCE default matters — what
          should missing forecasts show? Zero? Last known? Ask the user."

        Gemini: "The AUM aggregation in the existing code deduplicates
          by is_primary_opp_record. Your new query doesn't. This will
          double-count multi-opportunity advisors."

rstack: [Triages feedback]
        Auto-applied: phase reordering, dedup flag addition
        Asking you: "What should missing forecast dates display?"

You:    Show last known value with a '(projected)' label.

rstack: [Updates guide, marks ready for execution]

        Implementation guide ready. 7 phases, 14 files, every phase
        has a validation gate. Run it in a fresh context.

Three agents explored in parallel. Two independent LLMs reviewed the plan. The dedup bug that would have silently double-counted AUM was caught before a single line of code was written. That's not a copilot. That's a team.

The compounding effect

This is the thing that changes everything. It's not visible on feature one. It's visible on feature five.

Feature 1: /auto-feature → council asks 8 questions → you answer all 8
Feature 2: /auto-feature → council asks 5 questions → 3 answered by precedent
Feature 3: /auto-feature → council asks 3 questions → patterns established
Feature 5: /auto-feature → council asks 1 question  → almost autonomous

Why? Because context-ledger captures every decision:

Decision #47: "AUM aggregations use is_primary_opp_record for dedup"
  Rationale: Multi-opportunity advisors would double-count without it
  Scope: src/lib/queries/*
  Alternatives considered: DISTINCT on advisor_id (rejected — loses opp detail)
  Captured: 2026-03-15 during /auto-feature AUM forecasting

Next time an agent touches AUM queries, it queries the ledger, finds this decision, and doesn't need to ask. The decisions are MCP-queryable — Claude Code can search them in real time.

And agent-guard keeps documentation current:

$ npx agent-guard sync

  ✓ CLAUDE.md — up to date
  ✗ design-guide.md — Section 2 references old API route structure
    → Auto-updated with current route inventory
  ✓ Schema docs — field dictionary matches Prisma schema

Every code-modifying pipeline runs agent-guard sync automatically. Your docs never go stale. The next agent that reads them gets accurate information.

The pipeline

rstack is a process, not a collection of tools. The skills run in the order a sprint runs:

Think → Plan → Build → Review → Test → Ship → Reflect
  │       │       │        │       │      │       │
  │       │       │        │       │      │       └── /retro, /decisions
  │       │       │        │       │      └── /ship, /land-and-deploy, /canary
  │       │       │        │       └── /qa, /qa-only, /benchmark
  │       │       │        └── /council, /refine, /review, /codex, /cso
  │       │       └── /auto-feature, /quick-update, /auto-refactor
  │       └── /plan-ceo-review, /plan-eng-review, /plan-design-review
  └── /office-hours, /design-consultation, /design-shotgun

Each skill feeds into the next. /office-hours writes a design doc that /plan-ceo-review reads. /auto-feature runs parallel exploration agents whose findings feed the implementation guide. /council sends that guide to two independent LLMs. /refine triages their feedback. Nothing falls through the cracks because every step knows what came before it.

The /auto-feature pipeline in detail

This is the primary build pipeline. Here's what happens when you run it:

/auto-feature "Add user dashboard with real-time metrics"
    │
    ├── Phase 1: Parallel exploration
    │   ├── /code-inspector    → traces types, construction sites, consumers
    │   ├── /data-verifier     → verifies schema fields, types, population
    │   └── /pattern-finder    → maps established patterns, flags drift
    │   │
    │   └── Synthesis → exploration-results.md
    │
    ├── Phase 2: Build implementation guide
    │   └── Phased plan with validation gates at every step
    │       Phase 1: Prerequisites (deps, config, migrations)
    │       Phase 2: Shared helpers
    │       Phase 3: Types / models / schemas
    │       Phase 4: Data layer (queries, API endpoints)
    │       Phase 5: Integration layer
    │       Phase 6: Presentation layer
    │       Phase 7: Remaining construction sites + agent-guard sync
    │       Phase 8: Validation and testing
    │
    ├── Phase 3: Council review (if API keys present)
    │   ├── OpenAI  → type safety, construction sites, query correctness
    │   └── Gemini  → business logic, data quality, pattern consistency
    │   │
    │   └── council-feedback.md (merged, deduplicated)
    │
    └── Phase 4: Self-triage
        ├── Bucket 1: Auto-apply (field names, phase ordering, patterns)
        ├── Bucket 2: Ask human (business logic, design decisions)  ← STOPS HERE
        └── Bucket 3: Defer (scope expansion, alt approaches)

All commands

Exploration agents (generated by rstack init, tailored to your project)

| Agent | Your specialist | What they do | |-------|----------------|-------------| | /code-inspector | Senior Engineer | Traces the full code path: type definitions → construction sites → consumers. Reports with file paths, line numbers, code snippets. Read-only — never modifies files. | | /data-verifier | Data Engineer | Verifies schema assumptions. Three tiers: live MCP queries (Tier 1), ORM schema reading (Tier 2), type definitions only (Tier 3). Checks field existence, types, population rates, edge cases. | | /pattern-finder | Staff Engineer | Maps established patterns in your codebase. Identifies canonical implementations, flags drift where multiple implementations diverge. Documents what to follow and what to avoid. | | /dependency-mapper | Architect | Maps dependencies and blast radius. Barrel file involvement, dynamic imports, server/client boundaries, circular deps. Determines if a refactor qualifies for the lightweight track. |

Build pipeline commands (rstack originals)

| Command | Your specialist | What they do | |---------|----------------|-------------| | /auto-feature | Tech Lead | Full feature pipeline: parallel exploration → implementation guide → council review → self-triage. Adapts depth based on greenfield vs brownfield. | | /quick-update | Senior Dev | Lightweight path for 1-5 file changes. Scope-checks and auto-escalates to /auto-feature when the change is larger than expected. | | /auto-refactor | Refactoring Specialist | Lane classification (mechanical → structural-safe → lightweight → structural-risky → blocked). Blast radius analysis. Council review for risky refactors. Audit remediation mode for dependency vulnerabilities, TODO cleanup, dead code. | | /council | Review Board | Sends implementation guide to OpenAI and Gemini for independent adversarial review. Each gets a tailored prompt. Merges and deduplicates feedback. | | /refine | Triage Lead | Applies council feedback. Three buckets: auto-apply (safe fixes), ask human (judgment calls), defer (scope expansion). Appends a refinement log. | | /decisions | Historian | Browse, search, and manage your project's decision history via context-ledger. Query by topic, scope, or date. Capture new decisions. Flag stale ones. | | /rstack-audit | Setup Doctor | Diagnose and fix rstack configuration issues. Interview-driven — asks what went wrong, investigates the infrastructure, fixes agent definitions, captures the fix as precedent. | | /help | Routing Assistant | Describe what you're trying to do. It matches you to the right command with example invocations. |

Sprint commands (from gstack, MIT licensed)

| Command | Your specialist | What they do | |---------|----------------|-------------| | /office-hours | YC Office Hours | Start here. Six forcing questions that reframe your product. Challenges premises, generates implementation alternatives. Design doc feeds into every downstream skill. | | /plan-ceo-review | CEO / Founder | Rethink the problem. Four modes: Expansion, Selective Expansion, Hold Scope, Reduction. Find the 10-star product. | | /plan-eng-review | Eng Manager | Lock architecture, data flow, edge cases, test plans. ASCII diagrams. Forces hidden assumptions into the open. | | /plan-design-review | Senior Designer | Rates each design dimension 0-10, explains what a 10 looks like, detects AI slop. Interactive — one question per design choice. | | /plan-devex-review | DX Lead | Developer experience review: personas, TTHW benchmarks, friction points. Three modes: DX Expansion, DX Polish, DX Triage. | | /review | Staff Engineer | Find bugs that pass CI but blow up in production. Auto-fixes obvious ones. Flags completeness gaps. | | /codex | Second Opinion | Independent review from OpenAI Codex CLI. Three modes: review (pass/fail), adversarial challenge, open consultation. Cross-model analysis when both /review and /codex have run. | | /cso | Chief Security Officer | OWASP Top 10 + STRIDE threat model. Zero-noise: confidence gate, independent verification. Each finding includes a concrete exploit scenario. | | /ship | Release Engineer | Sync main, run tests, audit coverage, push, open PR. Bootstraps test frameworks if you don't have one. Auto-invokes /document-release. | | /land-and-deploy | Release Engineer | Merge → CI → deploy → verify production health. One command from "approved" to "verified in production." | | /canary | SRE | Post-deploy monitoring. Watches for console errors, performance regressions, page failures. | | /benchmark | Performance Engineer | Page load times, Core Web Vitals, resource sizes. Before/after on every PR. | | /investigate | Debugger | Systematic root-cause debugging. Iron Law: no fixes without investigation. Auto-freezes scope. | | /retro | Eng Manager | Team-aware weekly retro. Per-person breakdowns, shipping streaks, test health. | | /document-release | Technical Writer | Updates all docs to match what shipped. Catches stale READMEs automatically. |

Design commands (from gstack, require Bun)

| Command | Your specialist | What they do | |---------|----------------|-------------| | /design-consultation | Design Partner | Build a complete design system from scratch. Researches the landscape, proposes creative risks, generates mockups. | | /design-shotgun | Design Explorer | Generates 4-6 AI mockup variants, opens comparison board, collects feedback, iterates. Taste memory learns what you like. | | /design-html | Design Engineer | Turn mockups into production HTML. Pretext computed layout — text reflows, heights adjust, layouts are dynamic. 30KB, zero deps. Detects React/Svelte/Vue. | | /design-review | Designer Who Codes | Same audit as /plan-design-review, then fixes what it finds. Atomic commits, before/after screenshots. |

Browser & QA commands (from gstack, require Bun)

| Command | Your specialist | What they do | |---------|----------------|-------------| | /qa | QA Lead | Opens real Chromium, clicks through flows, finds bugs, fixes them with atomic commits, generates regression tests. | | /qa-only | QA Reporter | Same methodology, report only. No code changes. | | /browse | QA Engineer | Give the agent browser access. Real Chromium, real clicks, real screenshots. ~100ms per command. | | /pair-agent | Coordinator | Share your browser across AI agents. One-time setup, scoped tokens, tab isolation, rate limiting. | | /setup-browser-cookies | Session Manager | Import cookies from Chrome/Arc/Brave/Edge into the headless session. |

Safety commands (from gstack)

| Command | What it does | |---------|-------------| | /careful | Warns before destructive commands (rm -rf, DROP TABLE, force-push). Override any warning. | | /freeze | Restrict edits to one directory. Prevents scope creep during debugging. | | /guard | /careful + /freeze combined. Maximum safety for prod work. | | /unfreeze | Remove the freeze boundary. |

Two modes: greenfield and brownfield

rstack auto-detects which mode to use when you run rstack init.

Greenfield (velocity-first)

Detected when your project has no source code yet (empty repo or config-only).

• Lighter exploration — agents have less to map
• Focus on establishing good patterns from the start
• Council review catches design issues early
• context-ledger starts capturing decisions from day one

Brownfield (correctness-first)

Detected when source directories (src/, app/, lib/, etc.) contain code.

This is the hardest part of the entire system and the highest-risk. If the mapper gets boundaries wrong, every exploration agent looks in the wrong places, and the implementation guide misses files.

rstack init (brownfield detected)

  Detected project structure:
    Source roots:    src/, app/                [high confidence]
    Data layer:      prisma/, src/lib/db/      [high confidence]
    API layer:       src/app/api/              [high confidence]
    Business logic:  src/lib/, src/services/   [medium confidence]
    Presentation:    src/components/, src/app/  [high confidence]

  ⚠ Medium-confidence categories detected. Review carefully.
  Would you like to edit these directories before generation? (y/n)

Safety rails:

• Confidence scoring — each directory category gets high/medium/low confidence
• User confirmation gate — you review and edit detected directories before generation (mandatory)
• Conservative bias — low confidence prefers broader inclusion over narrow exclusion
• Monorepo detection — triggers conservative mode with warnings
• Visible summary — every generated agent file shows "Detected Directories" at the top
• Canary validation — post-generation check that every referenced directory actually exists
• Post-hoc correction — /rstack-audit fixes mapper mistakes; context-ledger captures the fix as precedent

Schema support tiers

rstack adapts data verification to what's available:

| Tier | Detection | Data verifier behavior | |------|-----------|----------------------| | Tier 1 | schema-context-mcp installed + supported warehouse | Live MCP queries. Field existence, population rates, value distributions, edge cases. Full verification against the actual database. | | Tier 2 | ORM schema files present (Prisma, Drizzle, TypeORM, etc.) | Schema file reading. Verifies fields from definitions. No live queries. Flags fields that can't be verified from files alone. | | Tier 3 | No database or unsupported | Type definitions only. Reads TypeScript/Python/Go types. Flags inconsistencies. No database verification. |

The setup wizard detects your tier automatically. You can upgrade anytime by installing schema-context-mcp:

npm install -g @mossrussell/schema-context-mcp

How rstack differs from gstack

gstack by Garry Tan is the velocity layer. It turns Claude Code into a virtual engineering team — 23 specialist skills for the full sprint cycle. rstack includes all of gstack's skills (MIT licensed) and adds production infrastructure on top.

| Capability | gstack | rstack | |-----------|--------|--------| | Browser automation (/browse, /qa) | ✅ | ✅ included | | Design pipeline (/design-shotgun, /design-html) | ✅ | ✅ included | | Sprint commands (/office-hours → /ship) | ✅ | ✅ included | | Safety guardrails (/careful, /freeze, /guard) | ✅ | ✅ included | | Code review (/review, /codex, /cso) | ✅ | ✅ included | | Decision history | — | ✅ context-ledger | | Documentation drift detection | — | ✅ agent-guard | | Cross-LLM adversarial review | — | ✅ council-of-models-mcp | | Deep schema verification | — | ✅ schema-context-mcp | | Brownfield codebase mapping | — | ✅ confidence scoring + user gates | | Structured refactoring | — | ✅ lane classification + blast radius | | Project-tailored agents | — | ✅ setup wizard generates from templates | | Multi-language support | Node.js only | Node.js, Python, Rust, Go, Ruby |

rstack is not a fork. It's an extension. gstack's skills ship as opaque runtime assets — they're not recompiled, just deployed. Attribution is preserved on every file.

Install

Requirements

• Node.js 20+ (required — download)
• Claude Code (required — install)
• git (required)
• Bun 1.0+ (optional — only for browser/design skills — install)

Step 1: Install rstack

npm install -g @mossrussell/rstack

This installs the CLI and deploys skills to ~/.claude/skills/rstack/. Takes ~30 seconds.

Step 2: Set up a project

cd your-project
rstack init

The setup wizard:

1. Detects your tech stack, database, project mode
2. Asks about your project, users, risk areas, conventions
3. Confirms detected build/lint/test commands
4. For brownfield: shows detected directories for confirmation
5. Generates exploration agents, slash commands, CLAUDE.md, design-guide.md
6. Initializes context-ledger and agent-guard
7. Registers MCP servers
8. Validates everything

Step 3: Add API keys (optional, for council review)

Create a .env in your project root:

OPENAI_API_KEY=sk-...    # https://platform.openai.com/api-keys
GEMINI_API_KEY=AI...     # https://aistudio.google.com/apikey

Council review is skipped when keys are missing — you can add them anytime and run /council to get the review.

Step 4: Start building

/help                              # See all available commands
/auto-feature "your feature"       # Full pipeline
/quick-update "small change"       # Lightweight path

CLI commands

rstack init        # Set up rstack for a project
rstack audit       # Run validation checks, diagnose issues
rstack upgrade     # Check for newer versions
rstack uninstall   # Remove rstack infrastructure from a project
rstack setup       # Redeploy skills (runs automatically on install)

All operations are subcommands of the single rstack binary. No standalone rstack-init etc.

What gets generated

After rstack init, your project has:

your-project/
├── .claude/commands/
│   ├── auto-feature.md          ← Tailored to your stack, risk areas, conventions
│   ├── auto-refactor.md         ← Tailored blocked areas, audit commands
│   ├── council.md               ← Tailored prompts with project context
│   ├── refine.md                ← Tailored with schema doc references
│   ├── quick-update.md          ← Tailored with your build/lint/test commands
│   ├── help.md                  ← Command router
│   ├── decisions.md             ← context-ledger viewer
│   ├── rstack-audit.md          ← Setup diagnostic
│   ├── code-inspector.md        ← Agent tailored to your architecture
│   ├── data-verifier.md         ← Agent tailored to your database tier
│   ├── pattern-finder.md        ← Agent tailored to your framework
│   └── dependency-mapper.md     ← Agent tailored to your module system
├── .claude/[prefix]-*.md        ← Schema reference docs (if database detected)
├── .context-ledger/             ← Decision history (queryable via MCP)
├── .agent-guard/                ← Documentation drift detection
├── design-guide.md              ← Synthesized from your interview answers
└── CLAUDE.md                    ← Standing instructions for your project

Every file is human-readable markdown. Every template variable is filled with your project's actual details. Open any file, read it, edit it. No black boxes.

Architecture

@mossrussell/rstack (npm package)
├── bin/rstack.js              Single CLI entry point (Commander subcommands)
├── dist/                      Compiled TypeScript
│   ├── cli/                   init, audit, upgrade, uninstall, setup handlers
│   ├── init/                  Setup wizard: detect → interview → generate → install → validate
│   ├── lib/                   Template engine, file writer, MCP registry, project context
│   └── templates/             .tmpl files filled by the generator
├── skills/                    Opaque runtime assets (NOT compiled by tsc)
│   ├── browser/               From gstack: /browse, /qa, /pair-agent (require Bun)
│   ├── design/                From gstack: /design-*, /design-html (require Bun)
│   ├── sprint/                From gstack: /office-hours through /retro
│   └── safety/                From gstack: /careful, /freeze, /guard, /unfreeze
└── src/templates/             Template source (backup of dist/templates/)

Infrastructure packages

| Package | Role | Install | |---------|------|---------| | @mossrussell/context-ledger | Decision history with MCP-queryable precedent | Bundled — auto-installed with rstack | | @mossrussell/agent-guard | Documentation drift detection | Bundled — auto-installed with rstack | | council-of-models-mcp | Cross-LLM adversarial review | Optional — requires API keys | | @mossrussell/schema-context-mcp | Deep schema verification via MCP | Optional — for Tier 1 database support |

Infrastructure deps are never installed into your project directory. context-ledger and agent-guard are bundled as regular dependencies of rstack and run via npx from the global install. rstack init works in Go, Rust, Python, and any non-Node.js project without polluting it with package.json or node_modules/.

Troubleshooting

Skills not showing up? Run rstack setup to redeploy skills to ~/.claude/skills/rstack/.

Agents looking in wrong directories? Run /rstack-audit for interview-driven fixes. Or edit the agent definitions directly — they're plain markdown in .claude/commands/.

Council review not working? Check your .env for OPENAI_API_KEY and GEMINI_API_KEY, then register the MCP server:

claude mcp add --scope user council-mcp -- npx council-mcp

Browser skills not working? Install Bun. Browser and design skills require Bun — core rstack features work without it.

Windows users: rstack is Windows-first. All paths use path.join(), home directory via os.homedir(), no symlinks, no shell scripts. bin/rstack.js enforces LF line endings via .gitattributes.

Template variable error during init? If the generator stops with "unfilled variables," the template engine caught a variable that wasn't filled. Check which template and variable are named in the error — it usually means the detector didn't find something the template expects. Run rstack init again with more detail in the interview, or file an issue.

ESM errors (ERR_REQUIRE_ESM)? rstack pins CJS-compatible dependency versions (chalk@4, ora@5, inquirer@8). If you see ESM errors, a dependency may have been upgraded. Pin it back.

Uninstall

# Remove from a project
cd your-project
rstack uninstall

# Remove globally
npm uninstall -g @mossrussell/rstack

# Remove deployed skills
rm -rf ~/.claude/skills/rstack

rstack uninstall removes .claude/commands/, .context-ledger/, .agent-guard/, and design-guide.md. It preserves CLAUDE.md (you may have added your own content).

Docs

| Doc | What it covers | |-----|---------------| | Commands Reference | Deep dive on every command | | Setup Guide | Detailed setup walkthrough | | Greenfield vs Brownfield | When to use which mode | | Council Setup | API keys, MCP registration, troubleshooting | | Schema Tiers | The three verification tiers explained | | Architecture | How rstack works internally | | Contributing | Dev setup, testing, how to contribute | | Assumption Checklist | Verified package facts and known deviations | | Skill Compatibility | Which skills work out of the box, which need Bun |

Attribution

rstack includes MIT-licensed components from gstack by Garry Tan. Browser automation, design pipeline, sprint commands, and safety guardrails are adapted from gstack with attribution preserved on every file.

The infrastructure layer — context-ledger, agent-guard, council-of-models-mcp, schema-context-mcp, the setup wizard, the template engine, the brownfield mapper, and the exploration agent framework — is original work.

License

MIT

Free, open source. No premium tier, no waitlist.

I built this because stateless agents kept breaking my production dashboard. If you're shipping anything where correctness matters, you'll hit the same wall. rstack is how I fixed it. Fork it. Improve it. Make it yours.