🏭 Hamzaish
Claude Code setup that builds, launches, and learns.
Your AI writes the code. Hamzaish runs the company.
Install · What it is · What's inside · Philosophy · Docs
See it work
Point Hamzaish at an idea — and run the whole company around the code your agent writes: idea → MVP → launch → sell → scale, with a brain that remembers every lesson and a judge that refuses to let "looks done" pass for "done."
The honesty is enforced, not promised → watch the guards run on every commit.
Quick start
Pick your path: 🌱 First time? Use the desktop app · 💻 Prefer Terminal? · ⚡ Already use Claude Code? · 🔧 Advanced
Install once, and Hamzaish works in every new chat, in any folder.
🌱 Using the Claude desktop app (easiest, no Terminal)
On Windows? Follow the Windows guide for now.
-
Get the app: download it from claude.com/download, open it, and log in (Pro or Max plan).
-
Install Hamzaish: open the Code tab, pick any folder (Documents is fine), paste this message, and press Enter. Click Allow when Claude asks to run it.
Install Hamzaish for me by running this, then tell me in plain words what happened:
curl -fsSL https://raw.githubusercontent.com/hamza-ali-shahjahan/hamzaish/main/install.sh | HAMZAISH_REGISTER_HOOK=yes HAMZAISH_REGISTER_GUARDS=yes sh
The yes parts turn on its reminders, update notices, and safety guards.
-
Start building: open a new chat in the Code tab so Claude picks up Hamzaish, type /builder-mode, and describe what you want to build.
Stuck? Ask Claude: run bun run doctor in my hamzaish folder and fix what it finds.
💻 Using Terminal
No coding and no GitHub account needed. You'll paste three lines into a window called Terminal.
On Windows? Follow the Windows guide instead.
Step 1 — Open Terminal
- Mac: press
⌘ Command + Space, type Terminal, and press Enter.
- Linux: press
Ctrl + Alt + T.
A window opens with a blinking cursor. For each step below, paste the line into that window and press Enter. Never used Terminal before? Here's a short guide.
Step 2 — Install Claude Code (the AI that does the building)
curl -fsSL https://claude.ai/install.sh | bash
✅ When it finishes, you'll see a success message.
Step 3 — Install Hamzaish
curl -fsSL https://raw.githubusercontent.com/hamza-ali-shahjahan/hamzaish/main/install.sh | sh
It asks three yes/no questions. Type y and press Enter each time. They turn on Hamzaish's plans and receipts, update notices, and safety guards.
✅ You'll see: Ready. Your factory is at ./hamzaish
Step 4 — Start Claude Code
claude
Any folder works: Hamzaish is now in every Claude Code chat. The first time, your browser opens so you can log in with your Claude account (Pro or Max plan). If Claude Code asks whether you trust this folder, choose Yes.
Step 5 — Build your idea
Type /builder-mode followed by what you want to build, and press Enter. Hamzaish shows you a plan first, then builds it step by step. You approve each step.
If something goes wrong
command not found? Close Terminal, open a new window, and repeat that step.- Your Mac asks to install "command line developer tools"? Click Install, wait until it's done, then repeat Step 3.
- Anything else: in a new Terminal window, run
cd hamzaish && bun run doctor. It tells you what's wrong and how to fix it.
⚡ Already use Claude Code?
curl -fsSL https://raw.githubusercontent.com/hamza-ali-shahjahan/hamzaish/main/install.sh | sh
Then open Claude Code in any folder and type /builder-mode <your idea>. Update any time with bun run update, and check your setup with bun run doctor.
🔧 Advanced
What it is
An open-source agent OS that puts you in Builder Mode and keeps you there for
the whole life of a product. Your agent supplies the hands. Hamzaish supplies
what makes those hands a company:
- A brain — learnings, decisions, and anti-patterns in markdown, SQLite-indexed,
searchable from any session. When a mistake generalizes it becomes a guardrail
the next build inherits, so your second product starts smarter than your first.
- A factory — 35 agents and 45 skills + 25 commands across
Ideate → MVP → Launch → Sell → Scale → Kill-or-double-down. Most AI tools stop
when the code is done; solo projects die after that — in the security review,
the launch, the pricing call, the kill decision.
- A judge — mechanical gates, walled off from the builder, that refuse to let
"looks done" pass for "done." That line is the difference between Builder Mode
and vibe coding, and it's the part evolving hardest.
Build is the default. The old advice — plan, size the market, twenty
interviews before you build — was written for when building was expensive.
Building is cheap and reversible now, so the thing you ship is the test.
Strategy is a rail you pull in when you want it, never a toll you pay to start.
One deliberate choice: Hamzaish ships no agent loop and no model of its own.
It rides an agent host — Claude Code today. That's the design, not a gap. Hosts
get replaced; your brain, your guardrails, and your judge shouldn't be.
(why → · running on other hosts →)
What's verified, and how
The honesty is enforced, not promised. Every claim below has a command you can run.
| Claim | How it's checked | Run it |
|---|
| Headline numbers match the filesystem | every count in this README is derived from disk; drift fails the build | bun run check-counts |
| Skills behave as specified | deterministic, agent-blind eval cases (no model or key needed) | bun run eval --no-llm |
| New skills carry evals | coverage ratchet — it can only go up, deleting a case fails CI | bun run check-evals |
| New skills state their limits | every new skill declares what it can't do | bun run check-limitations |
| Decisions record what they beat | decision · why · alternatives · wrong-if · revisit | bun run check-decisions |
| A deployed product is really live | read-only assertions against the real URL — DNS, TLS, authz, build-SHA | bun scripts/verify-live.ts <url> |
| Nothing ships unreviewed | 70-check security review with a forced BLOCK/CLEAR verdict | /security-check |
| No per-user legal fines on launch day | Age gate, self-hosted fonts, replay off, CAN-SPAM footer, renewal terms, DMCA — scanned before every ship, fixed by PR | /legal-check |
| What was actually checked | exit codes recorded to a hash-chained ledger, rendered into the receipt | bun run verify --show |
Green looks like ✓ all headline counts match disk, an eval summary of
PASS=17 SKIP=9, and silent exit-0 from each guard.
What's inside
| | |
|---|
| 🧠 A brain that remembers | learnings, decisions, and anti-patterns — SQLite-indexed, searchable from any session via /brain-ask | brain/ |
| 🏭 A factory that acts | 35 agents + 70 skills & commands across the lifecycle — idea validation, architecture, scope-guarding, landing copy, SEO, cold outreach, retention, kill-or-double-down | factory/ |
| 📖 Playbooks with receipts | 54 playbooks · 148 practices — each badged ✅ proven by a real ship / 🟡 partial / ⏳ research-baked | BEST-PRACTICES.md |
| 🔒 A gate that blocks | 70-check pre-launch security review (backend-reality, auth, authz, data exposure, secrets) with a forced BLOCK/CLEAR verdict | security checklist |
| 🧪 An engine that proves | eval-gated build cycle — a feature slice without a named eval + an end-to-end test doesn't get built | /full-cycle |
| 📡 Senses that record | four local-only instruments from your first session (gitignored, nothing leaves your machine): session traces (bun run trace-report), friction (bun run friction), the defect registry (bun run defect), and per-skill trust states (bun run skill-report) — retros ground in what happened, not what you remember | scripts/trace-report.ts |
|
Every count real, every item linked, every claim badged. The full catalog, expanded:
One router + 31 lifecycle-stage agents + 3 engineering subagents under factory/agents/. Each is a markdown SKILL.md your session invokes by intent — the routing table lives in CLAUDE.md.
💡 Idea stage (7)
| Agent | What it does |
|---|
| idea-generator | Generate startup ideas grounded in your patterns, current trends, and validated demand signals |
| problem-sharpener | Turn vague observations into testable hypotheses with specific who/when/severity/workaround |
| devils-advocate | Build the strongest case AGAINST an idea; hunt disconfirming evidence |
| market-researcher | TAM/SAM/SOM, trends, buyer landscape — anchored in citable public data, not vibes |
| competitor-mapper | Map the landscape by tier (direct/indirect/acquirer/adjacent) and argue why each could win |
| customer-discovery | Target profile, prospect list, interview script, outreach setup |
| interview-synthesizer | Synthesize interview batches into evidence-for vs evidence-against |
🏗️ MVP stage (5)
| Agent | What it does |
|---|
| architect | Define the architecture BEFORE a line is written — CLAUDE.md, scope.md, 1-page ADR |
| builder | Drive build sessions with enforced discipline: read context first, one topic per session |
| scope-guardian | Block scope creep — every feature ask pressure-tested against scope.md |
| security-reviewer | Pre-launch review: auth, data exposure, input validation, dependency vulns |
| metric-framework-designer | North star, activation, retention targets, Sean Ellis — defined BEFORE launch |
🚀 Launch stage (9)
| Agent | What it does |
|---|
| brand-story-builder | Positioning, story, voice, naming, visual primitives |
| landing-page-copywriter | Hero + value props + social proof + objections + CTA, anchored on validated pain |
| seo-strategist | Content hubs, target keywords, internal linking, schema, technical baseline |
| keyword-researcher | Real keyword data from GSC + Ahrefs Webmaster + DataForSEO |
| content-marketer | Content calendars and drafts — blog, social, LinkedIn, threads |
| launch-strategist | Product Hunt, Hacker News, X, LinkedIn, newsletters — sequenced for compounding signal |
| cold-outreach | First 100 customers by hand: sourcing → personalized messages → cadence → tracking |
| pricing-strategist | Packaging, tiers, anchor, monthly vs annual, free vs trial |
| community-builder |
📈 Scale stage (6)
| Agent | What it does |
|---|
| growth-loops | Design acquisition/monetization/engagement loops (Reforge framework) |
| retention-analyst | Retention curves, churn drivers, leaky-bucket vs activation-problem diagnosis |
| pricing-optimizer | Post-PMF pricing iteration from real willingness-to-pay data |
| support-triage | Categorize, prioritize, draft responses; bug vs user-error vs feature-request |
| moat-builder | Workflow lock-in, data network effects, domain depth, integration depth |
| compliance-auditor | SOC2 / GDPR / HIPAA / CCPA gap analysis with prioritized remediation |
🗂️ Portfolio (4) + the router
🔧 Engineering subagents (3)
| Agent | What it does |
|---|
| code-reviewer | Deep multi-axis review of a change before merge |
| security-auditor | Hunts injection, authz gaps, secret exposure, unsafe deserialization |
| test-engineer | Designs and fills test coverage; reproduces bugs as failing tests |
45 skills + 25 commands under factory/skills/ and factory/commands/ — auto-discovered by Claude Code after bun run setup. Every /name has exactly one home — a skill folder or a command file, never both (same-name pairs double-load into session context; CI enforces it).
| Invoke | What it does |
|---|
/builder-mode | The front door — enter Builder Mode: default is just build; strategy rails are opt-in, skip anytime. (Alias: /hamzaish — same engine.) |
/scaffold | One-shot a new product: folders, starter, config, CLAUDE.md, scope, PRD skeleton |
/validate | Full validation pass: sharpening, devil's advocate, market sizing, competitor map, discovery plan |
/ideate | Generate ideas grounded in your portfolio patterns + current trends |
/work-on | Enter a product workspace with full context loaded |
/portfolio-pulse | All products: one table, top 3 priorities, on-fire, don't-touch |
/product-pulse | One product: metrics, stage, blockers, the #1 action today |
/kill-or-keep | Quarterly review with forced verdicts for every product |
/launch-plan | Full launch playbook: PH, HN, X, LinkedIn, email warm-up, outreach, pricing, brand assets |
/web-launch | Verification-gated website launch: per-project workbook, refuse-to-launch sign-off gate, post-launch monitoring |
(skill) launch-gotchas | Library of real launch failure modes — indexation, redirects, analytics undercounting — with the fix for each |
(skill) pseo-at-scale | Programmatic-SEO discipline for 100s–10,000s of templated pages: thin-content prevention, indexation ramp |
/release | Cut a polished GitHub Release from the changelog at a major-cycle boundary |
/keyword-research | Clustered keyword brief from GSC + Ahrefs Webmaster + DataForSEO |
/seo-aeo-bootstrap | Ship the SEO + AEO foundation: llms.txt, AI-bot robots.txt, JSON-LD, sitemap, meta block |
/name-product | End-to-end naming pipeline: brief → competitors → generate → clear → select → lock |
/name-clearance | Clear a name BEFORE buying the domain: collision, trademark signal, availability |
🔧 The engineering cycle — /full-cycle and its phases
Consolidated into Hamzaish so the build engine ships with the repo (no separate install). /builder-mode routes here for real builds — starting from a goal, slicing it into features that can each be proven (an eval + an end-to-end test), and only then spec'ing and building. Features you can't evaluate or test don't make the cut.
| Invoke | What it does |
|---|
/full-cycle | The gated engine: GOAL → SETUP → SLICE → SPEC → PLAN → TEST → BUILD → REVIEW → SHIP, pausing for approval at each gate |
/goal | Pursue a measurable objective autonomously — rubric + fresh-eyes verification, iterate to the bar, resumable run-log (sibling of /builder-mode) |
/auto | The same cycle run autonomously end-to-end — no per-gate stops; still pauses for irreversible/outward actions |
(skill) feature-slicing | Slice a goal into provable feature slices — keep only the ones that come with an eval + an end-to-end test |
(skill) write-a-goal | Forge a fuzzy ambition into a measurable, reachable goal — metric + evals + acceptance + non-goals |
/spec | Write a structured spec before any code (for the selected slices) |
/plan | Break the spec into small, ordered, verifiable tasks |
/build | Implement the next task incrementally (TDD: red → green → refactor → commit) |
/test | Drive behavior with tests; browser-test real UIs via DevTools |
/review | Five-axis code review — correctness, readability, architecture, security, performance |
/code-simplify | Reduce complexity for clarity without changing behavior |
/setup | Bootstrap a project's Claude Code context (CLAUDE.md, rules, a starter command) |
Backed by 22 engineering skills under factory/skills/ — feature-slicing, spec-driven-development, planning-and-task-breakdown, incremental-implementation, test-driven-development, debugging-and-error-recovery, code-review-and-quality, security-and-hardening, performance-optimization, frontend-ui-engineering, api-and-interface-design, browser-testing-with-devtools, ci-cd-and-automation, documentation-and-adrs, git-workflow-and-versioning, source-driven-development, context-engineering, deprecation-and-migration, code-simplification, shipping-and-launch, idea-refine, auto-orchestrator — invoked by name as the cycle runs.
BEST-PRACTICES.md — 148 practices for shipping products with Claude Code: 46 ✅ proven by real ships and dated incidents · 3 🟡 partially proven · 99 ⏳ research-baked from named sources. Anti-patterns lead — each one cost us something real. Every line links to its deep-dive playbook and its source.
Playbooks are short (300–800 words), sourced, stage-gated:
Architecture
brain/ — identity, principles, learnings, anti-patterns, decisions, ingested knowledge
factory/ — agents (idea/ mvp/ launch/ scale/ portfolio/), skills, commands, playbooks
products/ — one folder per product: metadata + learnings ONLY (code stays in private repos)
evidence/ — dated artifacts behind the claims, failures included
meta/ — changelog, retros, evals, the self-improvement loop
stack/ — tech defaults + the set-up-once accounts guide
templates/ — Next.js starter + doc templates
Product code is never in this repo — only metadata and learnings. Your code
(the moat) stays private; locations are wired via a git-ignored
code-paths.local.json, so the repo is safe to share without exposing anyone's
secret sauce. (the public/private boundary →)
The discipline
- Build is the default — validate before irreversible bets. Cheap, reversible
ships are validation. Before expensive moves: ~5 target-profile conversations.
Never skip it silently —
bun run check-validation <slug> records the debt.
- Scope is the moat. Every product's
scope.md says what it does AND deliberately doesn't.
- Persistent context. Every product gets a
CLAUDE.md; every decision logged in decisions/.
- Measurement before launch. North-star, activation, retention — defined before the first user.
- The factory is a product. If it can't ship product #1 through, fix the factory before adding slots.
- Honest copy. Every outward-facing word is true when it ships; aspiration is
labelled, never present-tense. (the honest ledger)
The self-improvement loop
Every working session appends learnings to brain/learnings/.
At cycle boundaries /learn-loop scores candidates on five axes and promotes only
the top few into load-bearing guardrails — a skill rule, a playbook step, an
anti-pattern, a ledger line. Quarterly, /kill-or-keep runs on Hamzaish itself and
re-checks each guardrail: deliver the predicted gain, or get sunset.
The ladder matters more than the lesson: a hook, then a CI guard, then an eval
case — and only then prose. A lesson that can be a check becomes a check.
Go deeper
Start here — total beginner · Your first product in 10 minutes · FAQ · Architecture · Philosophy · How it compares · Running on other hosts · Where it's heading · Security model · Contributing · Changelog
💛 Built on a thousand generosities
We stand on giants, and we're loud about it.
Read the full credits →
The backbone is hard-won venture experience — the Business-SWAT roles, opportunities, and mentors that came with years at Disrupt.com, taking things from zero to one before AI made building cheap. On that foundation, the patterns studied and credited — Addy Osmani's spec→ship discipline, Karpathy's eval-driven flywheel, gbrain (knowledge graph), Anthropic's Founder's Playbook (lifecycle framing), hermes-agent (self-improving skills), openclaw (multi-channel gateway), and ponytail (multi-agent portability) — sharpened that instinct and 10×'d the AI and agentic-building learning on top of it. The 2026-07 four-repo study — Graft (NanoNets), Adrian (Secure Agentics), AgentENV (kvcache-ai), and OpenSpace (HKUDS) — continued the pattern: two of its ideas became bun run skill-report and the eval judge's untrusted-output boundary, credited in references/README.md and ACKNOWLEDGMENTS.md. Study material lives in references/, never imported.
License
MIT — use it for anything, including your own paid products.
In plain English: copy it, change it, build and sell whatever you make with it. Just keep the copyright notice in copies of Hamzaish. See LICENSE.
The license covers the code, not the name. Fork freely, but give your fork its own name and logo.
It's 11pm somewhere.
/builder-mode <your idea> — get into yours.
Built in public by Hamza Ali. The factory's repo runs on the factory's own discipline.
