Graph-first, quality-driven, design-aware AI development workflow.
One prompt. Full lifecycle. Technically correct. Visually crafted.
macOS / Linux:
python3 --version # need 3.8+
git --version # any recent version
pip3 install graphifyy
graphify --version # verifyWindows:
python --version # need 3.8+ — install from python.org if missing
git --version # install from git-scm.com if missing
pip install graphifyy
graphify --version # verifyGraphify installs globally — no need to install it separately per project. Works just like
git: install once, use everywhere. Runs entirely locally — no API calls, no data sent anywhere.macOS PATH note: if
graphifyis not found after install:echo 'export PATH="$HOME/Library/Python/3.x/bin:$PATH"' >> ~/.zshrc && source ~/.zshrcWindows PATH note: if
graphifyis not found, use as fallback:python -m graphify --version
macOS / Linux:
git clone https://github.com/MertCapkin/graphcraft /tmp/graphcraft
cd your-project
bash /tmp/graphcraft/install.shWindows (Git Bash):
# Open Git Bash (comes with Git for Windows)
git clone https://github.com/MertCapkin/graphcraft C:/graphcraft-tmp
cd /c/Users/YourName/your-project
bash /c/graphcraft-tmp/install.shWindows (WSL2):
git clone https://github.com/MertCapkin/graphcraft /tmp/graphcraft
cd /mnt/c/Users/YourName/your-project
bash /tmp/graphcraft/install.shWindows users:
board.shand other bash scripts require Git Bash or WSL2. Download Git for Windows (includes Git Bash): https://git-scm.com/download/win
The installer copies into your project:
.cursor/rules/graphcraft.mdc— Cursor loads this automatically on every sessionorchestrator/,.cursor/skills/,handoff/,scripts/— full workflow system- Detects your OS and shows the appropriate graphify setup instructions
New project with no code yet? Skip this step — Bootstrap Mode handles it.
Open your project in Cursor and type in the chat:
/graphify .
The . means "scan the current project directory".
Graphify is installed globally — no per-project setup needed.
Just open your project in Cursor and run this command.
How long does it take?
| Codebase size | Time |
|---|---|
| < 50 files | ~5 sec |
| 50–200 files | ~15–30 sec |
| 200–500 files | ~1–2 min |
| 500+ files | ~3–5 min |
Creates graphify-out/GRAPH_REPORT.md, graph.json, and graph.html.
Run once. Update with /graphify --update after significant changes.
Windows PATH issue? Use this fallback in Cursor chat:
python -m graphify .
Open a new Cursor chat and paste:
Existing codebase:
Read orchestrator/ORCHESTRATOR.md and follow it exactly.
[Describe what you want to build or fix]
New project from scratch:
Read orchestrator/ORCHESTRATOR.md and follow it exactly.
This is a new project with no existing codebase.
I want to build [describe your idea].
Tech stack: [language, framework, database].
GraphCraft handles everything from here — planning, designing, building, reviewing, testing, shipping.
GraphCraft is an AI development workflow for solo developers who want studio-quality output without a studio.
It combines three things:
Graphify — builds a queryable knowledge graph of your codebase. Every role navigates this graph instead of re-reading raw files from scratch.
Role-based orchestration — 7 specialized roles run automatically: Bootstrapper → Architect → Designer → Builder → Reviewer → QA → Ship.
Quality as a first-class constraint — not just "does it work" but "is it clean, consistent, accessible, and something you'd be proud of."
Token savings are a byproduct of doing this well — not the goal.
Plans and scopes. Identifies blast radius via graph. Writes testable briefs with a UX Intent block for UI features. Routes to Designer or Builder based on feature type. Reads handoff/ARCHITECTURE.md to enforce structural decisions.
Translates UX intent into precise, implementable specs: every state (default, hover, focus, loading, error, empty), spacing, typography, tokens, motion, accessibility. Determines which layer (atom/molecule/organism) the component belongs to. No guessing by Builder.
Implements exactly the brief and design spec. Quality bar always active: correct, clean, consistent, complete, considered. Follows existing codebase patterns and layer constraints from handoff/ARCHITECTURE.md.
Verifies four sections: brief compliance, design spec accuracy, code quality, and graph side effects. Also checks for architecture layer violations (atom importing organism, logic in View layer, etc.). Code that works but is poorly written gets rejected.
Runs two tracks: functional (call path tracing, boundary conditions) and experiential (loading states, error messages, keyboard navigation, responsive behavior).
Pre-deploy checklist, smart graph update (structural changes only), commit message generation with quality summary.
For new projects: decomposes an idea into ordered modules, creates handoff/ARCHITECTURE.md (frontend layers, backend layers, cross-cutting rules), writes a cross-cycle memory file, generates each cycle's brief from the actual graph — not just the plan.
GraphCraft enforces structural decisions across every cycle through handoff/ARCHITECTURE.md:
Frontend — Atomic Design layers:
atoms/ — Button, Input, Icon (no imports from above)
molecules/ — FormField, SearchBar (imports atoms only)
organisms/ — LoginForm, UserMenu (imports atoms + molecules)
templates/ — AuthLayout, DashboardLayout
pages/ — LoginPage, DashboardPage
Backend — Layered architecture:
controllers/ — HTTP in/out, no business logic
services/ — all business logic, no DB calls
repositories/— all DB calls, no business logic
models/ — data shapes only
State pattern: MVVM via hooks — custom hooks as ViewModels, components as pure Views.
Architect writes the layer decision into every brief. Designer enforces it in the spec. Reviewer catches violations. The codebase stays consistent from day one.
You: "Add rate limiting to login."
[ARCHITECT] graph + architecture → scope → brief (with UX intent if UI)
↓ auto (if UI)
[DESIGNER] UX intent → design spec (all states, tokens, layer, accessibility)
↓ auto
[BUILDER] brief + spec → implementation (quality bar + architecture rules)
↓ auto
[REVIEWER] 4-section check: brief + design + quality + side effects + layer violations
↓ auto (loops to Builder if anything fails, max 3×)
[QA] functional + experiential verification
↓ auto
[SHIP] checklist + graph update + commit message
You: "Build a task management REST API. TypeScript, Express, Postgres."
[BOOTSTRAPPER] idea → ARCHITECTURE.md + BOOTSTRAP.md → Cycle 1 brief
↓ auto
[... full cycle ...]
↓
/graphify . ← first graph from real code
↓
[BOOTSTRAPPER] reads real graph → Cycle 2 brief (informed by what was actually built)
↓ auto
[... repeats until all modules complete ...]
| Mechanism | Saving |
|---|---|
| Graph-first reads (vs re-reading files) | ~70–85% on architectural queries |
| Role discipline (each reads only what it needs) | ~50–60% vs unstructured |
| File-based state (no chat history re-reads on resume) | ~60% per new session |
| Designer prevents visual rework cycles | ~30–50% over project lifetime |
| Codebase | Without GraphCraft | With GraphCraft | Saving |
|---|---|---|---|
| Small (10–20 files) | ~40k/day | ~28k/day | ~30% |
| Medium (50–100 files) | ~180k/day | ~54k/day | ~70% |
| Large (200+ files) | ~600k/day | ~90k/day | ~85% |
your-project/
├── .cursor/
│ ├── rules/graphcraft.mdc ← always-active (Cursor auto-loads)
│ └── skills/
│ ├── bootstrapper/BOOTSTRAPPER.md
│ ├── architect/ARCHITECT.md
│ ├── designer/DESIGNER.md
│ ├── builder/BUILDER.md
│ ├── reviewer/REVIEWER.md
│ ├── qa/QA.md
│ └── ship/SHIP.md
├── orchestrator/
│ ├── ORCHESTRATOR.md
│ └── TOKEN_OPTIMIZER.md
├── handoff/
│ ├── BRIEF.md
│ ├── REVIEW.md
│ ├── STATE.md
│ ├── BOOTSTRAP.md
│ ├── ARCHITECTURE.md ← structural decisions (layers, patterns, rules)
│ └── board/todo/ doing/ done/
├── graphify-out/ ← generated by graphify (commit this)
├── scripts/
│ ├── board.sh
│ └── post-commit
Standard session:
Read orchestrator/ORCHESTRATOR.md and follow it exactly.
[What you want to build or fix]
New project:
Read orchestrator/ORCHESTRATOR.md and follow it exactly.
This is a new project with no existing codebase.
I want to build [describe your idea].
Tech stack: [language, framework, database].
Resume a previous session:
Read orchestrator/ORCHESTRATOR.md and follow it exactly.
Resume from last session.
Single roles (advanced):
# Architect only
Read .cursor/skills/architect/ARCHITECT.md and follow it exactly.
Read orchestrator/TOKEN_OPTIMIZER.md for token rules.
# Designer only
Read .cursor/skills/designer/DESIGNER.md and follow it exactly.
Read orchestrator/TOKEN_OPTIMIZER.md for token rules.
Brief is in handoff/BRIEF.md.
# Builder only
Read .cursor/skills/builder/BUILDER.md and follow it exactly.
Read orchestrator/TOKEN_OPTIMIZER.md for token rules.
Brief is in handoff/BRIEF.md.
# Reviewer only
Read .cursor/skills/reviewer/REVIEWER.md and follow it exactly.
Read orchestrator/TOKEN_OPTIMIZER.md for token rules.
Review the changes in [file or "the last git diff"].
# QA only
Read .cursor/skills/qa/QA.md and follow it exactly.
Read orchestrator/TOKEN_OPTIMIZER.md for token rules.
Trace and verify [feature name].
.cursor/rules/graphcraft.mdcloads automatically in Cursor — never reference it manually.
bash scripts/board.sh status
bash scripts/board.sh new add-oauth Add OAuth login
bash scripts/board.sh claim add-oauth builder
bash scripts/board.sh complete add-oauth
bash scripts/board.sh logEvery board operation creates a git commit. Full audit trail via git log handoff/board/.
| Project type | Fit |
|---|---|
| REST / GraphQL API | ⭐⭐⭐⭐⭐ |
| Monolithic web app | ⭐⭐⭐⭐⭐ |
| React / Vue SPA | ⭐⭐⭐⭐⭐ (Designer role particularly valuable) |
| Data pipeline / ETL | ⭐⭐⭐⭐⭐ |
| Library / SDK | ⭐⭐⭐⭐⭐ |
| Admin panel / dashboard | ⭐⭐⭐⭐⭐ |
| Microservice | ⭐⭐⭐⭐⭐ |
| CLI tool | ⭐⭐⭐⭐ |
| Mobile app (React Native) | ⭐⭐⭐⭐ |
| Unity game (C#) | ⭐⭐⭐⭐ |
| Serverless | ⭐⭐⭐⭐ |
| E-commerce backend | ⭐⭐⭐⭐ |
| Flutter app | ⭐⭐⭐ |
| DevOps / automation | ⭐⭐⭐ |
| Rapid prototype | ⭐⭐ |
| Static site | ⭐ |
| Tool | Support |
|---|---|
| Cursor | ✅ Full (.mdc auto-loads) |
| Claude Code | ✅ Full |
| VS Code Copilot | ✅ Full |
| GitHub Copilot CLI | |
| Aider |
See CONTRIBUTING.md. GraphCraft is markdown and bash — low barrier by design.
MIT — free forever. No telemetry. No accounts.