Queue 50 features. Walk away. Come back to merged, validated code.
aishore is the sprint orchestration layer for Claude Code. You define what to build and why. It picks items from your backlog, develops each one through a quality protocol, validates against your intent, and merges the result — autonomously, in batch, with full git workflow.
.aishore/aishore auto done # drain the entire backlog, hands-offAI coding tools are single-session. You prompt, it codes, the session ends. To ship 20 features you sit through 20 sessions — managing branches, reviewing output, catching regressions, re-prompting on failures. There's no batch execution, no quality gates between items, no memory of what was already built.
aishore is the layer between "AI can write code" and "AI can run a sprint."
You provide three things per item: what to build (title + steps), why it matters (commander's intent), and how to verify it (acceptance criteria + your test suite). aishore handles the rest.
┌─────────────────────────────────────────────────────────────────────────┐
│ Sprint Orchestrator │
│ │
│ Pick ─→ Branch ─→ Preflight ─→ Develop ─→ Validate ─→ Merge/Archive │
│ │ │ │
│ └── retry ───┘ │
└─────────────────────────────────────────────────────────────────────────┘
For each item, the orchestrator:
- Picks the highest-priority ready item and creates a feature branch
- Pre-flights your test suite against the unmodified codebase (catches broken baselines before wasting a sprint)
- Develops through a 3-phase maturity protocol — all in one session while context is hot:
- Implement — write the code
- Critique — stop, re-read everything, verify each AC, hunt bugs and edge cases, fix what's found
- Harden — run validation again, fix regressions, confirm all AC are provably met
- Validates — runs your test suite, checks scope, then an independent Validator agent reviews the diff against acceptance criteria and commander's intent
- Merges the feature branch, pushes, and archives the completed item with full metadata
Failed items retry with failure context fed back to the developer. If all retries exhaust, an AI agent refines the spec and tries once more. A circuit breaker stops the session if failures cascade.
# Install (into .aishore/ — no global dependencies)
curl -sSL https://raw.githubusercontent.com/simonplant/aishore/main/install.sh | bash
# Initialize (auto-detects your stack and test command)
.aishore/aishore init -y
# Add a backlog item with intent
.aishore/aishore backlog add \
--title "Add health check endpoint" \
--intent "Ops must know instantly if the service is alive or dead. No false positives."
# Run one sprint
.aishore/aishore run
# Or drain the entire backlog autonomously
.aishore/aishore auto done --retries 2 --refineSee the full quickstart guide for detailed setup and your first sprint walkthrough.
The most important concept in aishore. Every item requires a commander's intent — a directive stating what must be true when the work is done. Not implementation instructions. The outcome.
| Intent (good) | Not intent (bad) |
|---|---|
| "Ops must know instantly if the service is alive or dead." | "Add health check endpoint" |
| "Users authenticate securely or are told exactly why they cannot. Never a blank screen." | "Implement OAuth login" |
| "Deploys that break the API contract must be caught before reaching production." | "Add contract tests" |
Intent is a hard gate. Items without it are skipped. When the spec is ambiguous, intent is what the developer follows. When the validator checks results, intent is the bar.
Autonomous batch execution. auto done drains the backlog. auto p0 does just the must-haves. Set --limit 10 for a capped session. Walk away; come back to merged code.
Quality that survives scale. The maturity protocol (implement, critique, harden) runs inside each session while the AI still holds full context. This isn't "retry until tests pass" — it's structured self-review that catches edge cases, intent drift, and regressions before the code ever leaves the developer session.
Full sprint lifecycle. Feature branches, pre-flight checks, scope enforcement, independent validation, merge, push, and archival. Every completed item is recorded with its original spec, outcome, duration, and line count.
Self-healing failures. Retries carry full failure context (prior diff, validator feedback, error logs). Spec refinement rewrites the steps and AC based on what went wrong. Circuit breaker stops runaway sessions.
AI-powered grooming. Tech Lead, Product Owner, and Architect agents decompose rough ideas into sprint-ready items. backlog populate reads your PRODUCT.md and generates a scaffolded backlog — skeleton items first, then features. groom --architect detects when a project is building fragments without a working top-down skeleton and injects scaffolding items. Auto-groom keeps the pipeline filled during long autonomous runs.
Zero config. Pure Bash, no build step. init -y detects your project type and test command. Works out of the box. Customize later via config.yaml or environment variables.
This project builds itself. Nearly every commit was generated by aishore's own sprint orchestrator.
| Metric | Value |
|---|---|
| Sprints completed | 268 |
| Commits generated | 589 (95% of repo history) |
| Bugs fixed autonomously | 178 |
| Features shipped | 44 |
| Releases in 53 days | 38 |
Browse the git history — the conventional commit messages, feature branches, and merge commits are all aishore's work.
"I already use Claude Code / Cursor / Aider." Those are session tools. aishore is the sprint layer on top. It handles what happens between sessions: backlog priority, git branching, quality gates, failure recovery, batch execution, and result archival. You keep your AI coding tool — aishore orchestrates it.
"Can't I just loop over prompts in a shell script?" You'd need to build: git branching per item, baseline pre-flight, a maturity protocol, retries with failure context, scope enforcement, auto-grooming, circuit breakers, spec refinement, independent validation, and sprint archival. That's what aishore is — already built, tested across 268 sprints.
"What about SWE-agent / OpenHands / Devin?" Those are AI agents that solve individual tasks. aishore manages the sprint, not the task. It handles item selection, quality gates, batch execution, and the workflow around the agent. It could wrap any coding agent; it currently uses Claude Code because it's the most capable for full-repo work.
| Quickstart | Install, configure, run your first sprint |
| Architecture | Pipeline, agents, quality model, design decisions |
| Configuration | Config file, env vars, CLI flags |
| Problems | Troubleshooting |
| Roadmap | What's next |
| Contributing | Dev setup, code style, PR process |
| Changelog | Release history |
v0.3.8 — Alpha. Battle-tested on its own codebase, used daily on real projects.
Works well: sprint orchestration, maturity protocol, autonomous mode, backlog grooming, scaffolding detection, architecture review, scope checking, spec refinement, checksum-verified updates.
Known limits: single-repo only, Claude Code CLI as the only AI backend, macOS/Linux only.
Simon Plant — building AI infrastructure tools.
- GitHub: @simonplant