“If you want to bring AI onto the team, you have to design the process before the tools.” – Affaan Mustafa, winner of the Anthropic x Forum Ventures hackathon

Dohyun Jung - Principal Consultant, ROBOCO

Everything Claude Code is a collection of configurations that turns the Claude Code CLI into a virtual development team environment. A hackathon winner spent ten months refining these recipes while building an actual startup product, then gathered them all into one public repository; apply them and you can summon Claude as a “senior engineer + QA + architect.”1 The repository is open for anyone to inspect on GitHub.

Everything Claude Code

This article is a technical report that lays out the repository structure, how it uses the Claude API, its technology stack, and what set it apart on the way to winning the hackathon. It closes with the current limitations and ideas for improvement.

TL;DR

  • Everything Claude Code is a set of configurations for running the Claude Code CLI like a virtual development team with separated roles.
  • It combines agents, skills, slash commands, rules, and hooks to turn planning, TDD, review, and documentation into a repeatable flow.
  • The point is not to bolt on as many tools as possible, but to enable only the context and guardrails you actually need so that Claude can work reliably.

1. Project Overview

Everything Claude Code is designed around a clear philosophy: “run Claude as a multi-role agent team.”1 The main session plays project manager, and the detailed work is carried out in parallel by a variety of subagents. The author also shared a real-world case study: with this setup, he built zenith.chat entirely with Claude Code and won the Anthropic x Forum Ventures hackathon in September 2025.2

The core value proposition has three parts.

  1. Role separation: separating prompts, tool permissions, and tone by role sharpens the LLM’s focus.
  2. Process standardization: slash commands like /plan, /tdd, and /code-review automate development routines.
  3. Quality guardrails: rules, skills, and hooks combine to enforce security, testing, and style.

Building on that philosophy, the repository as a whole forms a complete development pipeline in which “the AI learns the project history and runs the tools itself.”

2. Repository Structure and Architecture

The repository manages the context Claude Code needs by splitting it into role-specific folders. In practice, users copy the files they need into their own ~/.claude or into a .claude directory at the project root to activate them.

2.1 Agents

agents/ is a collection of role-specialized prompts. Representative examples include planner, architect, code-reviewer, security-reviewer, tdd-guide, build-error-resolver, e2e-runner, refactor-cleaner, and doc-updater.2 Each file uses YAML frontmatter to define the model (opus), the allowed tools (Read, Grep, Bash, and so on), and a description, while the body holds the role-specific instructions. The central design perspective is to keep tools to a minimum in order to increase focus and prevent role conflicts between agents.

2.2 Skills

skills/ is the team’s shared operating manual. It includes coding-standards.md, backend-patterns.md, frontend-patterns.md, security-review/, tdd-workflow/, and more.2 tdd-workflow in particular spells out the RED→GREEN→REFACTOR loop and the 80% coverage requirement in detail, so that Claude automatically reminds itself of test-driven development. Skills can be operated in two tiers: organization-wide (~/.claude/skills) and project-specific (.claude/skills).

2.3 Commands

commands/ holds slash command prompts such as /plan, /tdd, /e2e, /code-review, /build-fix, /refactor-clean, /test-coverage, and /update-docs.2 The user simply types a command in the chat, and the prompt matching that procedure is loaded along with the skills and agents it needs. That makes it possible to run a whole development flow — “plan the feature → run TDD → review the code → sync the docs” — at the press of a button.

2.4 Rules

rules/ contains the guardrails that always apply. It is modularized into files such as security.md, coding-style.md, testing.md, git-workflow.md, agents.md, performance.md, patterns.md, and hooks.md, and Claude Code automatically injects every rule in this folder into the system prompt. For example, testing.md states a “no PRs below 80% coverage” rule so the model will not allow tests to be skipped.

2.5 Hooks

hooks/hooks.json defines automation scripts to run at Pre/Post ToolUse points. Examples include a hook that warns when a console.log is left behind after editing a TypeScript file, and one that runs a formatter before the session ends.2 A hook matcher specifies the tool name and file pattern, and the hook is configured to run a Bash command or an additional command. It acts as a safety net that automatically watches for recurring mistakes such as forgotten debug code or missing tests.

2.6 MCP Configuration

mcp-configs/ provides configuration templates for a number of MCP servers, including GitHub, Supabase, Vercel, Railway, and ClickHouse.1 Users paste the entries they need into ~/.claude/settings.json and fill in the API keys, after which Claude can call those service APIs directly. The README also offers a guideline: “no more than 10 active MCPs per project, and no more than 80 tools total.” Enabling too many MCPs eats into the context window and degrades model performance.

2.7 Plugins & Examples

plugins/ is a set of documents explaining the Claude Skills Marketplace and how to install external plugins. The examples/ folder includes project-level (CLAUDE.md) and user-level (user-CLAUDE.md) configuration samples along with a custom statusline.json, so new users can copy them verbatim and get started. The result is that the repository doubles as both a reference implementation and a template set.

3. Principles for Using the Claude API

The AI usage principles Everything Claude Code emphasizes boil down to these four.

  1. Multi-agent parallelization
    The main session sets the overall direction while subagents take delegated responsibility for the details. Because each agent handles only its own domain context, response quality and speed stay consistent.1

  2. TDD and test-first
    The /tdd command and the tdd-workflow skill enforce the RED→GREEN→REFACTOR cycle, and the testing.md rule requires at least 80% coverage. Whenever Claude receives a feature request, it always raises the need to add tests.

  3. Security and quality guardrails
    security.md codifies rules against hardcoded secrets and requirements for input validation, error handling, and vulnerable-library checks. The /code-review command and the code-reviewer agent make AI review code that AI wrote, forming a self-refining loop.

  4. Context budget management
    The more MCPs, rules, skills, and tools you enable, the more bloated the system prompt becomes, so the README repeatedly stresses “enable only the configuration you need.”2 Keeping a minimal per-project setup to preserve focus is what determines how efficiently you can use Claude.

Because of these principles, Claude Code functions not as a simple code completion tool but as a prompt engineering + workflow engine.

4. Technology Stack and Toolchain

Everything Claude Code is itself a Markdown- and JSON-based configuration collection, but the following stack sits behind it.

  • Anthropic Claude Code CLI: the runtime that assembles the system prompt and brokers calls between the LLM and the tools. It supports the latest Opus/Sonnet models.
  • A bundle of MCP servers: it ships MCP templates for major SaaS products such as GitHub, Supabase, Vercel, Railway, and ClickHouse so Claude can call those APIs directly.1
  • Testing and quality tools: the /e2e command is designed around running Playwright, and testing.md internalizes the JS testing stack including Jest and Vitest. /build-fix is written to deal with Node/Vite build errors.
  • Frontend/backend patterns: frontend-patterns.md contains React/Next.js guidance, and backend-patterns.md collects API, database, and caching best practices. There are also skills for specific data technologies, such as clickhouse-io.md.

In other words, while the repository presents itself as “language- and framework-neutral,” its first target is TypeScript-based full-stack web products. Using it for another language or domain means writing additional skills.

5. What Set It Apart on the Way to Winning the Hackathon

The competitive edge Everything Claude Code demonstrated at the hackathon comes down to five things.

  1. Role parallelization: design, implementation, and testing were handled simultaneously by different agents, reducing development bottlenecks.
  2. A standardized development routine: the /plan → /tdd → /code-review → /update-docs sequence was automated, so per-feature cycles were short and consistent.
  3. Full-stack automation: thanks to MCP, Claude handled GitHub issues, Supabase queries, Vercel deployments, and more on its own, leaving the human free to focus purely on product logic.3
  4. Hook-based safeguards: hooks such as console.log removal and missing-test warnings caught mistakes early and kept quality up.
  5. Battle-tested know-how: because the author packed in prompts and rules he had validated repeatedly in real work, it was not “one person’s one-time insight” but a polished framework.

That combination produced an “AI-led team” that maintains high quality even in a short window, and that is what worked as the differentiator at the hackathon.

6. Technical Limitations and Directions for Improvement

However polished it is, real challenges remain.

  1. Context window limits
    Turning on too many MCPs, rules, and skills shrinks Claude’s usable token budget and causes context loss in long sessions. Dynamic context loading, or the ability to swap configurations at the moment they are needed, is a future improvement point.

  2. Model cost and availability
    Opus models are slow and expensive. The burden grows with usage, so an automatic fallback strategy to Sonnet or another model is needed. An abstraction layer for plugging in non-Anthropic models is also worth considering.

  3. Onboarding difficulty
    Because you have to understand the concepts of agents, skills, and hooks all at once, the initial learning curve is steep. An interactive setup wizard or GUI-based configuration management would lower the barrier to adoption.

  4. Domain bias
    The current skills are optimized for JS/TS web services. For it to become a general-purpose framework, the community has to keep adding skills and commands for other domains such as embedded, data science, and mobile.

  5. Execution safety
    The risk that an agent granted Bash permissions runs the wrong command still exists. That is why safeguards such as two-step command approval, a sandbox mode, and a /dry-run command will be needed going forward.

  6. Performance optimization
    Having the AI explain every action as it executes it can be slow. Without optimizations such as response caching or sharing results between agents, the experience drifts away from “coding fast.”

7. Closing Thoughts

Everything Claude Code is not a mere collection of configuration files; it is closer to an operating system for how you work with AI. By combining role-scoped prompts, test-centric rules, hook-based automation, and MCP integration, it offers a concrete answer to the question “how do you use AI as a teammate?” At the same time, the challenges around context management, onboarding, and domain expansion are equally clear. The moment you port this repository into your own project and layer your organization’s processes and domain knowledge on top, AI stops being an assistive tool and becomes a sustainable development partner.

References

  1. https://tilnote.io/en/pages/696db2d265a2e4dd63f35cc7 ↩︎ ↩︎ ↩︎ ↩︎ ↩︎

  2. https://github.com/affaan-m/everything-claude-code ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎

  3. https://jpcaparas.medium.com/the-claude-code-setup-that-won-a-hackathon-a75a161cd41c ↩︎