Claude Bootstrap and Maggy: config pack and routing server
Claude Bootstrap + Maggy
A pack of skills, hooks and rules for Claude Code with enforced tests and cross-session memory, plus a local server that routes work across models
- 711 ★ on the repository
- Last commit
- MIT
Broad access
Why this level
- The installer deletes and recreates `~/.claude/skills` and `~/.claude/rules`, and the hooks and delegation scripts get access to your commands and files
- The Maggy server sends requests to several model vendors, and project context and API keys from the environment go with them
- Polyphony runs agents in Docker containers with a full repository clone, and automatic post publishing and git push need your review
Install
- Works in
Manual install
git clone https://github.com/alinaqi/maggy.git && cd maggy && ./install.shInstalls Claude Bootstrap in about half a minute. The script recreates `~/.claude/skills` and `~/.claude/rules`, so back up your own first.
Access and checks
How we reviewBroad accessThe tool can change data, run commands or handle secrets.
- The installer deletes and recreates `~/.claude/skills` and `~/.claude/rules`, and the hooks and delegation scripts get access to your commands and files
- The Maggy server sends requests to several model vendors, and project context and API keys from the environment go with them
- Polyphony runs agents in Docker containers with a full repository clone, and automatic post publishing and git push need your review
This is third-party code. Review the repository files before installing.
What it does
The repository has two parts. Claude Bootstrap is installed by `install.sh` and puts commands, 73 skills, conditional rules, hooks and templates for Python, TypeScript, React, mobile work, databases and security into `~/.claude`. Stop hooks keep Claude Code from treating a task as finished while tests fail. Quality gates cap functions at twenty lines, three parameters and two levels of nesting. Web projects get visual validation by default: a skill records a captioned Playwright run as a video that doubles as an end-to-end test. Cross-session memory has two layers: Mnemos keeps checkpoints that account for session fatigue, and iCPG stores why code was written and catches drift from intent. Architectural changes require an ADR, and when one is missing it is reconstructed from git history. Maggy installs separately, as the `maggy-harness` package from PyPI. It is a local FastAPI server with a dashboard at `localhost:8080`: it scores the complexity of each message from 1 to 10 and routes it to the cheapest capable model across 13 tiers, from a local Qwen3 up to Claude Opus. Alongside it sit Cortex MCP, a code-analysis server with 15 tools on a single SQLite database, and Polyphony for parallel agents in Docker.
Who it is for. For engineers and small teams who work in Claude Code every day and want to pin tests, architecture records and model savings down with rules in configuration.
Good fit when
- You want Claude Code to stop calling a task done with red tests, which the stop hooks handle
- Session context overflows and gets lost, and you need Mnemos checkpoints and recovery of code intent through iCPG
- Simple requests should go to cheap models and hard ones to Claude, which the Maggy router does with a budget cap
- Several agents work in one repository and step on each other, so you need the container isolation from Polyphony
- Large files clutter the context: the `context-shunt-gate` hook hands them to a cheap model and returns a short summary
Not a fit when
- `~/.claude` already holds your own skills and rules: the installer deletes the `skills` and `rules` folders and copies its own, so back them up first
- You need one small skill: the pack drags along 73 skills, hooks and templates, which is a lot of surface to review
- The team is not ready for strict rules: limits on function length and parameters, mandatory tests and ADRs will get in the way on prototypes
- You want routing but do not plan to run a local server and hold keys for several model vendors
Example request
Review the auth middleware for timing attacks: score the task, pick a route, find the ADR in docs/adr, then run the review with that contextLimitations
Running `install.sh` changes the Claude Code home folder: it copies hooks, commands and templates there and puts delegation scripts into `~/bin`. When Kimi CLI or Codex CLI is detected, the script adds the skills to their folders too.
Maggy needs Python 3.11 or newer, and Polyphony needs Docker or OrbStack. API keys are not required to start, but routing to cloud models works only with vendor keys: DeepSeek, Kimi, Gemini, Grok, OpenAI and Anthropic. Codex mode uses either a ChatGPT subscription through `codex login`, for delegation only, or an OpenAI API key.
The `context-shunt-gate` interception only suggests by default and does not block reads. The pack grows fast: version numbers in the project description and in the installer itself differ, and the router's list of models and tiers changes from version to version.
How to disable. Restore your saved copies of `~/.claude/skills`, `~/.claude/rules` and `~/.claude/settings.json`, delete the hooks and templates the installer placed, and remove the Maggy package with `pipx uninstall maggy-harness`. The delegation scripts live in `~/bin`.
FAQ
How do I install Claude Bootstrap?
Clone the repository and run the script: `git clone https://github.com/alinaqi/maggy.git`, then `cd maggy && ./install.sh`. The next Claude Code session picks up the skills and hooks on its own. Save your `~/.claude/skills` and `~/.claude/rules` first, because the script recreates them.
How is Maggy different from Claude Bootstrap?
Bootstrap is skills, hooks and rules in `~/.claude`, installed in about half a minute. Maggy is a separate local server with a dashboard: routing across 13 model tiers, skill protocols, plugins and Cortex MCP. It needs Python and, optionally, Docker.
How do I start the Maggy server?
Run `pipx install maggy-harness`, then `maggy bootstrap` and `maggy serve`. The server finds local repositories by itself and opens the dashboard at `localhost:8080`. API keys are not needed at the start, and `GITHUB_TOKEN` and `ANTHROPIC_API_KEY` can be added later.
Does the pack work with Codex and Kimi?
Yes, by the author's description the skills fit Claude Code, Codex, Kimi and Gemini CLI. When the installer detects Kimi CLI and Codex CLI it copies the skills into `~/.kimi/skills` and `~/.codex/skills`.
What does Cortex MCP do?
It is an MCP server for code analysis bundled in the repository. It builds a graph with ten edge types, computes cyclomatic complexity, searches a full-text FTS5 index and serves 15 tools on top of a single SQLite database.
Discussion
No questions or reviews yet.
Related
SkillsA Claude Code workspace folder: hooks with a local Ollama detect the project type, pick skills and remind you to update the docs
Workflows for Claude Code: /do, /omo, /bmad-pilot and more commands, with Codex, Gemini or OpenCode writing the code through codeagent-wrapper
A set of /sc slash commands, agents and behavior modes for Claude Code, from brainstorming and research to implementation and tests
A learning kit for Claude Code: feature walkthroughs plus copy-paste templates for commands, skills, memory, hooks and subagents
A Russian-language Claude Code course of 12 modules and 8 labs with a ready kit of skills, subagents and hooks for a project
A Claude Code plugin marketplace with ready sets of agents, slash commands, hooks and skills, plus a search site
README in short
A decision table compares the quick Bootstrap path with the full Maggy install. Then come routing and "push to git" protocol examples, theses on the problems the project solves, and a feature list with tests. Notes on changes by version and documentation links sit at the bottom.
README badge
Original SKILL.md
--- name: base description: Universal coding patterns, constraints, TDD workflow, atomic todos when-to-use: Always loaded as foundation for all projects - TDD workflow, simplicity rules, atomic todos user-invocable: false effort: medium --- # Base Skill - Universal Patterns ## Core Principle Complexity is the enemy. Every line of code is a liability. The goal is software simple enough that any engineer (or AI) can understand the entire system in one session. --- ## Simplicity Rules These limits apply to every file created or modified. ### Function Level - **Maximum 20 lines per function** - if longer, decompose IMMEDIATELY - **Maximum 3 parameters per function** - if more, use an options object or decompose - **Maximum 2 levels of nesting** - flatten with early returns or extract functions - **Single responsibility** - each function does exactly one thing - **Descriptive names over comments** - if you need a comment to explain what, rename it ### File Level - **Maximum 200 lines per file** - if longer, split by responsibility BEFORE continuing - **Maximum 10 functions per file** - keeps cognitive load manageable - **One export focus per file** - a file should have one primary purpose ### Module Level - **Maximum 3 levels of directory nesting** - flat is better than nested - **Clear boundaries** - each module has a single public interface - **No circular dependencies** - ever ### Enforcement Protocol **Before completing ANY file:** 1. Count total lines - if > 200, STOP and split 2. Count functions - if > 10, STOP and split 3. Check each function length - if any > 20 lines, STOP and decompose 4. Check parameter counts - if any > 3, STOP and refactor **If limits are exceeded during development:** ``` ⚠️ FILE SIZE VIOLATION DETECTED [filename] has [X] lines (limit: 200)