Multi-step workflows and automation patterns for Claude Code.
A task, meeting, and multi-coder harness that runs the same job across Claude, Codex, Gemini, Grok, and Ollama. Reports outcomes in English or German and ships an AI-readable docs index via llms.txt. Useful if you want several coding agents to compare notes on one problem.
Turns Claude Code into a phase-aware software factory with hard gates between stages, so work cannot advance until the current phase passes review. Bundles Clean Architecture and Effect coding standards, an adversarial review step, and token-budget discipline. Aimed at teams that want structure instead of free-form agent runs.
A cognitive-architecture layer that packages specialized agents and structured workflows, then deploys them to Claude Code, Codex, Copilot, Cursor, Factory, Warp, and Windsurf. The point is writing your process once and running it wherever you work. Useful when a team is not standardized on a single harness.
Models long agent runs as a governed DAG with durable state, bounded per-node context, and recoverable side effects, so a crash mid-run does not lose progress. Ships as a CLI and MCP server plus plugins for Claude Code, Codex, and Copilot. Built for multi-day jobs that exceed a single context window.
While generating certification practice banks with Claude Code, the author found roughly 78% of items were near-duplicates: different scenarios and distractors, identical answer logic. Both lexical and embedding similarity scored those pairs at 0.13-0.18 cosine, i.e. genuinely distinct. Handing the items to fresh-context Claude agents with the prompt 'which of these are the same question wearing a different hat?' found them, a reusable pattern for semantic dedup where vector search fails.
An orchestration layer for running heterogeneous agents together instead of committing to one vendor's harness. Handles the coordination between Claude, Codex, and Agy so each can take the parts of a task it handles best. Relevant if you're already paying for several agent tools and want them on one job.
A Claude Code plugin for frontend work that repurposes Plan mode's write block as a design review gate: a read-only spec primer runs before any code is written. Adds visual verification of the rendered result and interactive design-token sync back to Figma. Targets the usual failure of agents producing code that compiles but doesn't match the design.
At each session's end, Claude is forced to answer a fixed set of questions: what local workaround did you apply, what claim couldn't you verify, where did the plan change, which fork needed manual correction. Answers become 'observations' tagged with a recheck-when trigger, plus a forward scan of assumptions now locked into the code. Rules are only written on the second or third instance of a shape, since acting at N=1 often fixes the wrong place.
Every bug fix starts with a markdown case file that names the observed symptom, what was actually investigated, and a root cause stating a mechanism. 'The nested skill call never returns control to the caller' passes the gate; 'the workflow is flaky' does not. Started as pure discipline against confidently wrong fixes and became a searchable, dated corpus of the project's recurring failures.
A conversational interview walks you through setting up persistent agent memory inside an existing Obsidian vault, generating memory files, session protocols, task boards, and per-client instructions. Keeps agent context in the notes system you already read rather than a parallel hidden directory. Works with Claude Code, Cursor, Perplexity, and Copilot.
Encodes the maintainer job as a single repeatable loop: triage the tracker, delegate the work, review hard, merge on green. Ships one version of the loop with per-repo differences expressed as config rather than prose variations of the same instructions. Aimed at maintainers drowning in issues across several repositories.
A written methodology for software projects where humans and AI agents work as collaborators rather than tool-and-user. Delivered as 12 markdown docs plus templates, git-based, with no SaaS or vendor lock-in. Process guidance rather than code — useful if you are trying to standardize how a team works with agents. CC BY 4.0.
A ranked writeup on what actually makes a codebase agent-friendly, backed by cited cases: fix flaky tests first (Clipboard Health saw flakes in 100% of PRs), cut CI loop time (Ramp went from 18 to 6 min P50), and curate AGENTS.md (a controlled study found 28.6% faster runs and 16.6% fewer tokens at equal quality). The rest: turn repeated corrections into hooks and CI gates, use greppable names, emit honest errors with no interactive CLIs, and read your agent transcripts.
A harness plugin that keeps DESIGN.md and docs/design/ tied to actual commits, so architecture docs cannot silently drift from the code. Includes verify, query, changelog, critique, runbook, and onboarding commands, plus a greenfield design interview and product-discovery mockups. Aimed at teams that want the agent to consult a real design record instead of re-deriving intent each session.
A practice post arguing that an agent never gets to say "done" — it has to show the file path, the diff, the URL, or the test output. The author audited a batch of "completed" tasks and found a third had produced nothing at all. The whole fix is one line in the instructions file: never report completion without attaching evidence.
An opinionated set of Claude Code plugins for GitHub-centric development: a git worktree plus draft-PR workflow, self-documenting issues, and work summaries. It also ships a separate reviewer bot that reviews PRs independently of the agent that wrote them. Useful if you want your agent sessions to land as reviewable PRs instead of direct commits.
Applies OpenSpec-style execution discipline to coding agents, so work follows a written spec rather than whatever the agent improvises. Portable across Claude Code, Codex, and OpenCode. For teams that want spec-first agent runs without adopting a whole framework.
Each agent session writes its own changelog fragment file, and two dependency-free scripts fold and condense them into the real changelog. Avoids the merge conflicts you get when parallel agents all edit CHANGELOG.md. Simple enough to drop into any repo.
A universal dev-team workflow with 16 specialist agents that runs on Claude Code, Codex, Gemini, Cursor, Antigravity, and opencode. Rules lazy-load to keep context small, and agents own separate paths and concerns so parallel runs do not collide. Useful if you juggle multiple CLIs and want one shared setup.
A governed agent-driven SDLC you fork into your own repo, built on NIST 800-53 Rev.5, CIS Supply Chain, and the AI RMF. Gates require actual evidence rather than the agent asserting it did the work. For regulated environments where agent output needs an audit trail.
A method for resisting anchoring on the first coherent design an agent produces: draft the architecture as a saved artifact, then run a separate review pass against that artifact without the original conversation's momentum. The prompt shape asks for named assumptions, one realistic alternative per decision, validation plans, and reversal triggers. Practical guard against agent-assisted tunnel vision.
A measured investigation into why Claude Code sessions fill their context faster than they used to, using the output_tokens_details.thinking_tokens field that appears in ~/.claude/projects/**/*.jsonl as of v2.1.228. The author documents four wrong conclusions along the way, including one retracted dramatic finding, and ships the analysis script. Worth reading for the method as much as the number.
An agentic workflow kit that configures OpenCode, Claude Code, Codex, and Cursor with a coordinated swarm, memory that survives restarts, a 24-agent squad, and a five-gate delivery workflow. Zero runtime dependencies. Large surface area, so try it on a scratch repo first.
An experiment pointing Claude Code at an empty Unreal Engine 5 editor with a one-line prompt, controlling the editor live over MCP after building a harness of tooling and skills first. The agent decided geography, districts, road network, traffic, weather, map screen, and menus on its own. The author's finding is that the hard part was context, not code: it kept hitting the compaction wall, so the only continuity was whatever it wrote down.
Lets peer AI agents talk through a shared folder with no human relay and no orchestrator, waiting at zero token cost when idle. Works on Windows, which many agent-coordination tools do not. The zero-token wait is the notable design detail.
Session workflow orchestration for Claude Code covering the full lifecycle from research through release, with dependency-aware parallelization and a brainstorming step at each stage. More structured than ad-hoc prompting across sessions. Suits longer projects where stages genuinely differ.
A zero-config goal-to-tasks engine for Claude Code that grades PRD validity, builds a dependency-ordered task graph, and gates execution on evidence. Refuses to proceed on a vague PRD, which is the point. For teams that start from written requirements.
A Chinese-language governance and instruction framework for Cursor, Claude Code, and Windsurf, bundling rules, workflows, skills, and subagents in one place. Opinionated and fairly heavy. Best treated as a reference for how to structure agent governance.
Role-based multi-agent orchestration for Herdr with durable task state, parallel git worktrees, and cross-vendor review. Durable state means a crashed run does not lose its place. Herdr-specific, but the design is readable as a general pattern.
Git rules normally live in instructions -- do not push to main, do not force-push, open a PR -- which agents mostly follow but are not bound by. This replaces write operations with four commands (start, commit, finish, status) where start creates the task branch, commit stays local, and finish runs checks then opens a draft PR. Reads stay unrestricted; only the decisions get taken away.
A multi-agent orchestration layer built on top of mattpocock-skills. The /route command classifies a spec's tickets and splits them across your Claude and Codex subscriptions, and /crew runs them as unattended waves of tmux child agents. Aimed at people who want parallel, hands-off execution of a planned backlog.
A discussion of "semantic anchors" — established terms like MECE, Clean Architecture, or Cockburn Use Cases that an LLM already knows in depth. Instead of spelling out what non-overlapping exhaustive categories mean, you write "make these MECE" and the model expands it. A cheap way to shorten prompts without losing precision.
A set of hands-on labs for understanding how AI agents actually work internally. The labs run on an existing Claude Code or Codex subscription rather than requiring an API key, which lowers the barrier for learning. Documentation is bilingual Chinese and English.
An AI-powered SDLC workflow system that moves a feature idea through structured, agent-driven phases: planning, building, verification, shipping, and maintenance. Instead of one-shot prompting, work is broken into explicit stages each handled by agents. Useful if you want a repeatable process wrapper around Claude Code rather than ad-hoc sessions.
Drops a team of AI agents, project memory, and an engineering process into any repository with a single command. Targets multiple harnesses — Claude Code, Cursor, and AGENTS.md — so the same setup travels across tools. Worth a look if you repeatedly hand-roll the same CLAUDE.md and agent scaffolding for each new project.
A harness for running Claude Code or Codex on extended unattended shifts with accountability built in. It structures long sessions so you can see what the agent did and why, instead of waking up to an opaque diff. Aimed at overnight or multi-hour autonomous runs.
A portable harness handling safe orchestration, skill routing, and configuration management across AI coding agents. The pitch is keeping your setup from being locked to one vendor's config format. Early-stage, but relevant if you run several agents side by side.
A build-in-public devlog on running a multiplayer game project almost entirely through agents. Notable details: 0.77 lines of test code per line of game code with the whole suite running on every prompt, and a routing setup where one model handles art and strategy while spawning separate agents for code. The open problem the author reports is that AI cannot tell whether gameplay is actually balanced.
A plain-markdown workflow that walks an engineer from zero to first users to first paying customers, with reality gates between phases so you cannot skip ahead on optimism alone. Being markdown-only, it works with any LLM or agent harness rather than binding to one tool. Aimed at developers who can build the product but stall at distribution.
Dopamine is a prediction-and-feedback loop for coding agents that stops them from mistaking motion for progress. Before writing custom code it checks whether the behavior already exists, whether config suffices, whether a project helper or installed dependency covers it, and only then writes something new. The author benchmarked it across 12 tasks and reports wins on code size, tokens, cost, and time.
A month of solo projects turned into 41 single-purpose SKILL.md files plus a router that picks the smallest party for each task. No MCP, no API keys, just markdown: the main session delegates big builds to an expensive-model subagent and mechanical work to a cheap one with a report format that bans essays. The load-bearing rule is that whatever builds a thing never evaluates it.
handoff splits agent work into two roles: a coordinator that writes the implementation plan and an executor that carries it out, leaving you to review rather than drive. It is pure CLI and works across opencode, Claude Code, grok, and codex. Remote development machines are supported, so the executor can run somewhere other than your laptop.
goblin-watcher turns a Linear ticket into a branch, a git worktree, and a running agent session in one step. Each agent gets its own worktree so parallel work does not collide. tmux windowing gives you a single place to watch and switch between all the concurrent sessions.
A six-month-old workflow built around a /worklog command that appends a reverse-chronological session log to worklog.md in the project root. The explicit purpose is knowledge transfer to future agents rather than proof of work, so entries are capped at two to three sentences and record the why, since git history already covers the what. A companion KnownPitfalls.md captures the gotchas that survive model regressions.
Running four or five agents at once turns your job into deciding who needs attention next, and supervision does not scale the way execution does. The author found that detecting agent state from output silence fails because Claude Code polls the terminal constantly and its replies land on the input stream. VS Code shell integration via OSC 633 turned out to be the reliable signal for command start, end, and exit codes, though running-versus-stuck still needs output inspection after stripping ANSI.
Community report that Claude Code's long-standing 'must read a file before editing it' guard is now bypassed for Opus 5, Sonnet 5 and Fable 5. The poster observed test clobbering as a side effect, especially with Fable overwriting existing tests when asked to add new ones. Useful context if you rely on that guard as a safety net.
Interviews the tacit knowledge out of your head, pins it into a PRD, then double-checks the coding agent's work against it and demands evidence for every completion claim. Agent-agnostic and deliberately simple. Aimed at the failure mode where an agent declares success without proof.
A build report on launching a digital-product business end to end in a single working day, with eight parallel Claude Code sessions each writing one deliverable. Covers the verification gates used to keep parallel agents honest and the Stripe re-verification done server-side before serving downloads. Read it for the parallel-agent coordination pattern more than the product.
Decentralized project management across repos driven by Claude Code, where git is the store and PR lifecycle is the task status. No backend to run. An interesting fit if your work already lives in PRs and you resent adding a separate tracker.
A personal vibe-coding workflow plugin for Claude Code and Codex built on one decision: is this a small job or a big one? That single grading call then drives clarification depth, whether to explore alternatives, whether to write docs, and how strict verification should be. Chinese-language docs. Deliberately light for small tasks.
A cross-agent convention: whenever a tool is customized or modified, append an entry to AGENT-LOGGER.md at the artifact root. Gives you a reviewable, reproducible trail of what the agent changed about its own environment. No tooling required — it is a protocol.
A trivial setup — a MISTAKES.md in the repo plus one line in CLAUDE.md telling the agent to log what happened, root cause and prevention. No tooling, no vector store. The report is that the agent actually reaches for the file unprompted, citing past decisions like 'this approach was avoided because...'. Worth reading for the honest account of what it does and does not fix.
A plan, delegate, verify workflow where the role (planner, implementer, verifier) is independent of the harness running it — so any role can run on Claude, Codex, Grok or Pi. Includes an enforced no-implement mode for planning roles and a cross-harness message bus. The orthogonality is the interesting design choice.
An evidence-driven autonomous loop for Claude Code built from independent agents, proof gates between phases, holdout attacks against the work produced, and a final audit. The holdout-attack step — adversarially testing the result with material the builder never saw — is the part worth stealing.
Runs your tasks to a verified done and feeds failures back into itself so the next run avoids them. Plain text files and real checks, no daemon to keep alive. The self-improving angle is common in pitches and rare in implementations — worth a look for the file format alone.
Page one covers working inside a session: keyboard shortcuts, prompt prefixes, permission modes, context management, slash commands and bundled skills. Page two covers everything around it — CLI flags, settings file precedence, permission rules, subagents, skills, hooks, MCP, CLAUDE.md and hook events. Free PDF, no signup.
One session ran a schema migration while another did 'unrelated' cleanup, and the cleanup session deleted the three-minute-old migration as unused. Session one regenerated it differently, leaving two plausible schema versions and a broken database. A concrete cautionary tale about running parallel sessions in one working tree.
The author found the frameworks are not interchangeable: Mem0 extracts reusable facts and preferences, MemU turns session history into markdown procedures, and the others solve different problems again. Argues you should name the specific problem — stale facts, repo scoping, procedure reuse — before picking a tool.
Raises the concern that running an agent inside a directory does not confine it to that directory — it has your whole filesystem and shell. Asks whether the exfiltration and accidental-deletion risks are real in practice and what setups people actually run. The comment thread is the value here.
A community-maintained awesome-list cataloging tools that orchestrate multiple coding agents. Useful as a starting map when you are shopping for a multi-agent runner rather than building one yourself. Low effort to browse, high breadth.
A Claude Code toolkit packaging planning, review, investigation, and shipping as D&D-flavored multi-agent workflows. Designed to be cloned into a repo, used, and discarded rather than maintained as a long-lived dependency.
Keeps a project roadmap as repo-resident state with explicit dependencies between steps, so an agent can always tell what is unblocked next. Drivable from the terminal or by any coding agent, which keeps planning and execution in the same source of truth.
Defines a task contract per unit of work and runs deterministic scope and verification checks against git state. If an agent edits outside the declared scope or fails verification, the check fails, giving governance that does not depend on the model behaving.
Stores agent continuity, evidence, and authority in git so a task can be handed between platforms without losing verified context. Aimed at teams that rotate between different coding agents and need the handoff to carry proof, not just prose.
Addresses the second half of spec-driven development: after a feature ships, hotfixes and refactors quietly desync the design docs from the code. Truthmark maps codebase areas to their governing documents and forces future changes to reconcile the docs, keeping them usable as agent context.
Structures requirements work as a multi-agent pipeline grounded in BABOK, using perspective-based reading so each reviewer agent hunts a different class of defect, plus explicit requirement smell detection. More rigorous than the usual one-shot PRD prompt.
A Chinese-language PM scaffold that converts raw requirements into a traceable, human-confirmed PRD. Uses six-state knowledge annotation to mark what is confirmed versus assumed, and hard human gates that the loop cannot skip.
A Claude Code subagent framework where each persona keeps its own memory that survives across sessions in a project, so specialists accumulate context instead of starting cold. Adds a live lead-and-crew channel for dispatching work, steering agents mid-task, and approving steps human-in-the-loop. Aimed at longer multi-agent efforts where losing context between runs is the main cost.
A Linear OAuth app registered as an agent: mention it or delegate an issue and it starts a Claude Agent SDK session on your own machine, with cwd pointed at an Obsidian knowledge base. CLAUDE.md rules and MCP servers load as in a normal session, answers appear in the issue thread, and follow-ups resume the session. About 946 lines of TypeScript, and it runs on a Claude Code subscription rather than an API key.
A personal AI coding workstation captured as code: an idempotent setup script, tmux and shell configuration, and template Claude Code instructions, skills, agents, and hooks geared toward spec-driven development. Useful as a starting point if you are assembling your own baseline rather than copying fragments piecemeal.
A lightweight layer over Claude Code sessions that keeps project context up to date, enforces explicit decision logs, and aims to reduce agent drift over long-running work. It targets the failure mode where an agent slowly loses the thread of earlier choices. Minimal setup compared with heavier orchestration frameworks.
A knowledge-governance system for multi-agent setups built around L0-L3 task tiering, explicit handoff protocols, and spec arbitration between agents. Includes a curated LLM and deep-learning knowledge base with full auditability.
Gives a Markdown knowledge base a metabolism: notes expire by default and are renewed by being used. The AI proposes what to prune or keep, but a human makes the final call on removals.
Wires an existing Claude subscription together with GitHub into a repeatable software delivery pipeline. Aimed at people who already pay for both and want them working as one system rather than two disconnected tools.
A code review workflow that requires findings to be backed by evidence from the diff rather than plausible-sounding assertions. Runs against both Codex and Claude Code.
A working guardrail configuration up for community critique: deny rm -rf, .ssh/.aws/.env reads, curl-pipe-bash and force pushes; ask for package publishing, sudo, and unknown MCP tools; allow ordinary reads, tests, and builds. The open question is where .env access and force push belong before approval fatigue sets in.
Runs Claude Code sessions that are aware of their own context state: a real context self-check, auto catch-up for armed panes, and a safe self-clear loop for long-running work. Backed by Kijito but usable standalone.
A user reporting none of the commonly cited Opus 5 annoyances describes their method: restart sessions whenever docs and solution are consistent, run at max effort in auto mode, and load two small self-made skills (keeping-it-simple, writing-asd-ste100). Projects maintain a requirements.md and dev-plan.md detailed enough to rebuild from.
A Claude Code plugin structuring nine agents into a conversion-design pipeline, from researcher through to an adversarial art director running on Opus and a QA inspector. Sixteen skills distill design-award and conversion research, and three mechanical QA gates fail the build — including a zero-dependency headless-Chrome audit over raw CDP that measures the rendered page rather than the source.
An installable Claude Code plugin organizing work across five agent teams, with hooks that block claims which do not hold up: test results that fail to reproduce and imports that do not resolve. Runs plain by default, with the tyrant theming optional.
Argues most agent setups are pets — individually prompted, watched, and corrected, which caps you at roughly two at a time. The cattle alternative: never instruct a worker directly, have an orchestrator spawn each agent with one job and exactly the context that job needs, and discard rather than nurse the ones that come back wrong.
Models the build loop as an explicit state machine with gates between stages, so an agent-driven pipeline can't skip ahead past unmet conditions.
A governed development method packaged as a Claude Code plugin. Deterministic Definition-of-Ready gates and a mandatory blind pre-mortem keep multi-PR, agent-built work from drifting apart across sessions.
An autonomous multi-agent development setup that takes an idea to production-ready software using specialized agents with full local codebase context, self-healing loops, and an auto-fix CI/CD flow.
Manages GitHub Agentic Workflow installations across many repositories declaratively, reconciling actual state against the desired configuration via gh aw.
Distills each team member's Claude Code auto memory into a shared AGENTS.md committed to the repo. Entries are filtered and deduplicated, and every change is gated behind a pull request so team memory gets reviewed rather than silently accumulated.
On VTE-based terminals like GNOME Terminal, Claude Code's /terminal-setup refuses to run, which normally breaks Shift+Enter multiline input. The fix is not to debug it: use Ctrl+J to insert a newline and Enter to submit.
A Claude Code orchestration harness built around a chief-operator charter, tier-routed review and planning workflows, an append-only evidence ledger paired with an input-axis token compressor, and a Stop hook that refuses to let a session end while work remains unverified.
A couple of weeks of measurement comparing a custom harness against plain Codex and Claude Code on identical tasks: the harness cost roughly 3x for the same patch and the same passing tests, with most of the overhead in the protocol rather than the work. The core argument is that these protocols are stateless, so adding tokens to an existing call is linear but adding a turn is quadratic — and MCP cannot batch calls, so every tool use is another full turn.
A development workflow for Claude Code that works one branch at a time: it requires a validated brief up front, generates a structured plan from it, and tracks progress with minimal update churn.
Turns coding sessions into a growing, versioned knowledge base for Cursor and Claude Code, with portable rule rendering so the same rules work across different agents.
A practical account of one developer's daily Claude Code habits after months of use. The core advice: always use git and push immediately (private repo if you're self-conscious), and always work in worktrees with versioning so parallel features never collide.
Argues that Opus 5 follows instructions well — including instructions you wrote long ago and forgot — so complaints about low-confidence, over-cautious behaviour often trace back to accumulated CLAUDE.md rules. The author compared common user complaints against Anthropic's docs and their own repo and compiled a list of instruction patterns that make an agent skittish.
A product-lifecycle system for software built with AI coding agents: capture what was learned during the work, verify that changes do what they claim, and keep published content current as the product moves.
One maintainer's personal operating system for running their open-source projects — rules, repository structure, task definitions, and agent skills that guide an AI agent consistently across every repo.
A technique for readers who find Opus 5's prose hard to parse: have Opus launch a Haiku 4.5 subagent at the end of each task whose only job is rewording the response into plainer language. The open question the author raises is whether the smaller model drops detail that mattered.
An open-source Codex skill and plugin for running code review through two models at once, pairing OpenAI Codex with Claude Code so each checks the other's reading of the diff.
Bi-directional traceability for AI-assisted development: an eight-phase chain with seven gates and 113 checks establishing that every commit traces back to the business goal that authorized it. Ships as a skill for Claude Code, Cursor, and OpenCode, backed by a hosted MCP server.
A beginner-oriented working method for agent setups. The central rule: always pick a main model smarter than the subagents it manages, because the reverse consistently goes badly. The rest covers defining your working method with the model up front and where instructions belong.
Cross-model peer review for coding agents. Claude Code, Codex CLI, and Gemini CLI consult one another as independent read-only engineering peers, so a second model can challenge a plan without being able to change the code.
A push for shared vocabulary in agentic coding, opening with the ratchet pattern: borrowed from a ratchet wrench that turns one way and locks, it means enforcing monotonic progress. The agent works one discrete sub-item at a time, and once a step passes mechanical verification — a test, a linter, a build constraint — that progress is locked and the agent cannot roll back or oscillate.
A GitHub Action running ASSERT evals in CI and failing pull requests that introduce paired safety regressions, putting eval results in the merge path rather than a dashboard.
A demo repo for the talk The Human Is the Loop, showing spec-driven development with a coding agent. Four slash commands work for both Claude Code and opencode, GitHub issues serve as the agent's persistent memory, and each task gets its own git worktree. A compact reference for wiring specs, issues, and worktrees into one loop.
A developer gave headless Claude Code and Codex processes an open-ended goal and coordinated them with a deliberately thin harness: a scheduler, shared documents, and a short constitution. Eight days later the project had 52 games, AI opponents, puzzles and original art, with agents proposing new requirements and extending the harness itself when they hit its limits. A concrete case study in letting orchestration stay minimal instead of reaching for an agent framework.
An account of an Anthropic staffer prompting Claude to attempt the Riemann Hypothesis with little more than encouragement. After 650 failed ideas, a second run spent a day and a half coordinating roughly 60 subagents that ran 2,400 shell commands, wrote hundreds of Python scripts, checked results against known zeta zeros and refereed each other's work. Interesting as a data point on how far self-directed subagent fan-out can be pushed.
The trigger layer for the Herdr runtime: pair a cron schedule with a prompt and it wakes an agent in a fresh git worktree to run while you sleep. Includes MCP config, an overlap guard so runs do not collide, run history, and a live board. Useful if you want scheduled unattended agent work without hand-rolling the locking and isolation.
A written walkthrough of how the Claude Code CLI is put together, from startup flow through to the design of its query engine. Aimed at people who want to understand or reimplement agent harness internals rather than just use them.
A portable gate that refuses to let a coding agent declare a bug fixed without producing evidence: the failing reproduction, the change, and the passing result. Targets one of the most common agent failure modes, where a plausible edit is reported as a fix that was never actually verified.
Splits a task so a capable model writes the plan and checks the result, while weaker and cheaper agents execute clearly bounded coding steps. The point is to spend expensive reasoning on decisions and verification rather than on mechanical edits.
Argues that pointing Claude at a whole repo and describing a feature in prose forces it to rediscover system boundaries every time. Proposes delegating at the level of a seam behind a specific interface, making six things explicit: bounded outcome, contract, editable files, off-limits surfaces, acceptance evidence, and integration points needing separate checks. Recasts CLAUDE.md as a router to authoritative contracts rather than an encyclopedia.
A repo template laying out a full AI-driven development lifecycle for Claude Code, self-hosted rather than tied to a service. Gives you a starting structure for running planning, implementation, and review phases as a defined process instead of ad-hoc prompting.
A Claude Code plugin, modeled on the official Codex plugin, that spawns DeepSeek Flash sessions from inside a CC session. The author uses Opus as the orchestrator and delegates bug-hunt verification passes across large repos to the cheaper model. Worth a look if you want a multi-model setup where the expensive model plans and a fast model does the sweeping.
Discussion of how to run work that spans multiple repositories. The author keeps all repos as siblings (never nested), runs one CC session per repo, and passes work between them by having an agent write a Markdown file into the target repo's messages/ folder for the other session to pick up. Comments compare this against running a single session over several repos at once.
A GitHub repo template that ships a governance framework — the "Agent Covenant" — defining what an autonomous coding agent may do unsupervised and where it must stop. Works across Claude Code, Antigravity, and Aider. Start here if you want guardrails scaffolded into a new project rather than written from scratch.
Turns a markdown implementation plan into a phased delivery pipeline: each phase becomes its own pull request with a gated auto-merge, so you approve progress one step at a time. Because the loop runs through the repo rather than a local terminal, you can drive a session from your phone. Good fit for long builds you want to supervise asynchronously.
Adds 'flow-wave' and 'register' commands so one orchestrator agent can drive multiple agents through waves of features. The chain runs project init, syncs planned tasks to GitHub issues, registers agents, then iterates through issues by dependency priority with approval gates. Built on Claude Code's inter-session SendMessage support.
A distilled seed kit of the operating doctrine behind a company that runs most work through Claude Code. Covers constitution architecture, verification that executes rather than reads, delegation and model routing, governed versus passive memory, and a 31-class failure taxonomy mined from real incidents. Meant to be handed to Claude so it can generate your own version.
One lead agent delegates to four runtime adapters covering different CLI coding agents, with a hard rule that no change merges if it was only reviewed by its own model family. Cross-family review is meant to catch the blind spots a model shares with itself. A concrete implementation of the implementer/auditor split many people build by hand.
Frames, compares, and records engineering decisions, then tracks decay of the evidence each one rested on so stale decisions surface instead of silently persisting. Enforces parity between what was decided and what is in the repo. Works across Claude Code, Cursor, Gemini CLI, and Codex.
One-shot setup that wires a local model such as Qwen3.6-27B or Bonsai 27B in as a subcontractor to Claude Code or Codex via a delegate CLI. Delegated work is test-gated, so the cheap model's output has to pass before it counts. A pragmatic way to cut token spend on mechanical tasks.
A two-agent framework where a Product Owner agent advises what to build and an AI Developer agent ships it. Targeted at client-facing teams building internal and client apps. Built and maintained by FuseBase.
An engineering write-up tracing the path from 'let Claude Code implement our PRs' through realizing it does not work, to building something closer to an actual software factory. Honest about the failure modes encountered along the way. Useful counterweight to the usual success stories.
An AI-assisted workflow built so the human ends up understanding the code, not just receiving it. Teaches as it goes, captures decisions, generates documentation, and assembles review material. A response to the review-fatigue problem of high-volume AI output.
A local, open-source reasoning framework for Claude and Codex containing 48 authored reasoning systems, selected conditionally rather than always applied. The selectivity is the design point — the cost of deeper reasoning is only paid when it pays off. Runs entirely locally.
Runs Claude Code, Codex, Gemini, Aider, or local models as a single crew while you approve the risky steps yourself. Every run log stays on your machine, and providers can be swapped without rewriting the flow. Provider-agnostic by design.
A write-up of an on-call loop where a production exception opens a labeled GitHub issue, which triggers a GitHub Action running claude-code-action with Opus at high effort. Claude uses a skill plus a read-only CLI to pull stack traces, traces, and logs, investigates root cause, then either edits code or leaves findings. The observability tool is swappable; the Claude Code mechanics are the transferable part.
A Python ADW engine runs coding agents through bounded phases while a Next.js cockpit observes and controls them, with the split being that agents propose and deterministic code decides. Both halves meet at a single SQLite trace treated as the source of truth. A clean architecture for keeping agent autonomy bounded.
A workflow for Codex and Claude Code that produces Jira estimates grounded in repository evidence rather than guesswork, then updates the tickets. Ties the estimate to what the code actually implies. Narrow but concrete.
An engineering workflow that takes a product idea through framing, phased implementation, and explicit next steps, with token efficiency as a stated design constraint. Positions itself against heavier spec-driven kits that burn context. Ends at a verified project rather than a spec document.
An agent playbook for generating thorough backend test suites driven by a persona matrix, covering Laravel, Symfony, Slim, Mezzio, and CodeIgniter 4. The persona matrix forces coverage of role and permission combinations that ad-hoc test generation misses. Framework-agnostic within PHP.
Demonstrates keeping Opus as the orchestrator while routing subagents to non-Anthropic models by pointing Claude Code at a local endpoint that remaps model names to different providers. Claude Code still spawns and manages the subagents; only name resolution changes. The author is candid that the run cost about $5 and produced little useful work — the point was proving the routing works.
Describes a Social Media Manager agent that discovers conversations, drafts in the author's voice, stops for approval, publishes, measures results, and returns a decision packet. Each scheduled run starts a fresh session; the function persists because instructions, state, and evidence live in a repo with a canonical CONTEXT.md rather than in the chat. A good template for running any business function on scheduled agent sessions.
A Claude Code plugin where every agent works from a single board and every action lands in one hash-chained record. The chained log makes the run history tamper-evident and auditable. Engine ships separately on PyPI as flightdeck-connect.
Defines your AI-coding discipline once in a tool-agnostic core, then installs it into Claude Code, Cursor, GitHub Copilot, Gemini CLI, Codex, and Windsurf. Avoids maintaining six divergent copies of the same process. Apache 2.0.
A framework for installing standardized rules, agents, and commands into projects across multiple technology stacks. Gives new projects a consistent Claude Code baseline instead of copying config by hand. Broad in scope.
A kit of Claude Code multi-agent workflows aimed at game development across Unity, Godot, web, WeChat Mini Games, and Cocos Creator. Each engine gets agent roles and task pipelines rather than one generic prompt. Useful if your project spans more than one engine or you want a starting structure for game-dev agents.
Defines a single agent configuration contract and projects it onto three harnesses, with routed capabilities, sealed cross-harness dispatch, per-node model tiers, and a live fleet view. The goal is to stop maintaining parallel setups for each tool. Formerly published as agent_setting.
A multi-agent workflow toolkit with global skills, workspace-local model profiles, and a runtime-neutral core, built Codex-first but able to export configuration for Claude Code and Copilot. The neutral core is the point — author once, project onto each runtime. Handy for teams split across different coding agents.
A prompt-level system of nested loops covering planning and executing repo work, safely implementing audit findings, greenfield design, brownfield improvement, and learning from failures. Each loop re-verifies its own output until the issue is genuinely closed. It ships as a single markdown contract, so adoption cost is low.
A Claude Code plugin marketplace packaging a project-agnostic work-management model: Request to Work item to Active release to Done. It gives AI-supported development a consistent delivery structure instead of ad-hoc task tracking. Installs via /plugin marketplace add and auto-updates as the version bumps.
A large opinionated Claude Code bundle that models a whole engineering organization rather than a single helper. It layers deep idea interrogation up front, TDD sprints during implementation, and hook-enforced quality gates before work is accepted. Ships 43 skills, 8 agents, and 13 hooks as one installable unit.
A scan of 2,204 merged agent-authored PRs on public GitHub found 86 that modified an instruction file (CLAUDE.md, AGENTS.md, .mcp.json, .cursor/, copilot-instructions.md). Of the 68 that modified an existing file, zero drew a human comment on the file itself, even in repos where the surrounding PR was reviewed. The file steering your agents effectively gets reviewed once, on the day it is created.
Builds a persistent architecture knowledge base by reverse-engineering monorepos and multi-repo setups into standard OKF schemas (PKC and SAC). Ships as plugins for Claude Code, Grok, Codex, and OpenCode, so the captured architecture is reusable across tools. Useful for onboarding agents onto large existing systems.
The author of a usage-limits SaaS walks through the techniques their tool automates, explicitly so readers can do it without buying anything. Covers where token burn actually comes from in a normal session and which habits move the number most. Self-promotional framing, but the underlying advice stands on its own.
A prompt orchestration layer spanning 5 modes, 7 phases, 39 skills, and 18 agents, packaged as a plugin for Claude Code, OpenCode, Codex, Cursor, and several others. Zero dependencies, so it installs as prompt assets rather than a runtime.
Companion code to a book on building Claude Code loops whose exit condition is evaluated by a computer, not asserted by the agent. It refuses to advance on the model's own say-so and prints what each iteration cost. The 'agent said it was done' failure mode is exactly what this targets.
Checks agent execution traces against a machine-checkable model of the procedure your team intended, then measures whether a change to your harness actually improved anything. Aimed at teams who keep tweaking prompts and hooks without knowing if it helped.
Orchestrates a plan, implement, review, verify agent team with each agent in its own git worktree, contained by Bubblewrap and cgroups, driven from a local control plane. The containment layer is more serious than most orchestrators bother with.
A large opinionated framework built around dual-process cognition, lifelong learning, parallel agent teams, and a planning pipeline that produces PRDs, ADRs, and TODOs. Cross-platform install. Substantial surface area, so expect to adopt the whole model rather than pieces.
A visual, evidence-backed handbook plus a hands-on lab covering coding agent architecture: harness design, tool definitions, context management, sandboxing, and reproducible traces. Documentation rather than tooling, but it is the kind of grounding most agent projects lack.
A Claude Code plugin with five language packs (Symfony, React, Python, Bash, AI/ML) and a three-level rules engine enforced both in hooks and in CI, so standards apply at write time and at merge time. Adds a correction-learning loop and 12 specialized agents.
Coordinates a fleet of coding agents from different providers on the same work, rather than assuming every agent is the same CLI. Useful if you deliberately mix models for cost or capability reasons.
An A/B harness that measures whether the CLAUDE.md and skill context you inject into every session actually changes what the agent does. Most projects accumulate this context on faith; this puts a number on it.
An operating harness for the transition from weekend vibe-coding to software you maintain. Targets three specific failures: every session starting with amnesia, old bugs reappearing, and changes marked verified that were never actually tested. Deliberately unexciting, which is the point.
A post-mortem on four production regressions in six weeks after going all-in on agents. The author's conclusion is that generation quality was never the problem: agent changes did exactly what the ticket asked while quietly altering adjacent behavior no test covered, because the suite was written when a human knew what they had touched. Describes the review loop they built to close that gap.
Argues that fighting a model's default behavior with system prompt patches is a losing strategy, and that picking a different model or tool that already behaves the way you want is more durable. Aimed at the endless stream of 'fix the model' advice that circulates after each release.
Spec-driven development that scales the ceremony to the size of the work via a tier table, with execution rules, artifact skeletons, and skills for building and maintaining a project's architectural canon. The tiering matters: most SDD frameworks impose the same weight on a typo fix and a rewrite.
A walkthrough of auditing what loads into a new session before you type anything, using /context all, and cutting the parts you never actually use. The author's setup went from roughly 35K to 13K startup tokens in one pass. Approximate numbers from a personal setup, but the method transfers.
A spec-driven development framework for Claude Code, structuring work from specification through implementation. One of several SDD approaches circulating; worth comparing against the alternatives before committing.
Batches GitHub issues into a dependency DAG and drives an agent through them in topological order with concurrency and budget controls, designed for unattended overnight runs. A single zero-dependency Python file.
A written protocol for approving agent edits plus a running log of error post-mortems, distilled from developing a commercial project with a coding agent. Russian-language, and process rather than tooling.
Routes work across persistent Claude sessions and models so your expensive model spends its context reasoning rather than burning it on repository search. The economic framing is right: search is the cheapest thing to delegate downward.
A 200-line program was given its own source code, a goal, and a rule: wake every 8 hours, improve something, keep the change only if the tests prove it safe. 132 days and about 600 sessions later it is 115,000 mostly self-written lines, and it journaled a letter to its next version every night. The book is those letters, curated with Claude Code.
Splits the development lifecycle into five stages, one skill per stage, with a named subagent for every role and hard gates between stages where correctness matters more than speed. The explicit gates are the differentiator from looser workflow packs.
Copy a .qa-ai/ directory into any QA or automation repo and it bootstraps agent commands that carry work from PRD and requirements through Gherkin tests, TestRail planning, traceability, automation feasibility, and PR-ready artifacts. Tool-agnostic across Claude Code, OpenCode, and Codex.
A developer measured whether a 24 GB M4 Pro Mac mini can serve local models next to a Claude Code workflow, reporting ~64 tok/s for GPT-OSS 20B in MLX FP4 even with 16 OrbStack containers running, and MLX roughly 19% faster than GGUF. The takeaway is that local inference is a complement to Claude Code rather than a replacement: use it for private codebase triage, boilerplate, and offline prompt experiments, then escalate to the frontier model. Useful reference numbers for anyone considering a hybrid local/cloud setup.
onus.ai structures research work in Claude Code as a four-stage pipeline (scout, test, write, judge) with iron rules enforced through hooks. It uses a guarded task graph with a progress-aware stopping rule so runs terminate instead of looping, and a four-reviewer gauntlet before output is accepted. Aimed at long research tasks where unbounded agent loops are the failure mode.
A walkthrough of RoboCo, an open-source self-hosted multi-agent setup that mirrors a software company org chart. Work flows through a task hierarchy (root task, cell task, subtask) with dedicated PM, developer, QA, documenter, and PR reviewer roles, and failed reviews cycle back to the original dev for revision. Interesting as a concrete example of role-based agent delegation with explicit escalation paths.
A large Claude Code configuration packaged as a multi-agent operating system: 134 agents across 15 categories, 14 plugins, and local-first routing. Orchestration is cost-aware, sending work to cheaper models or local execution where it makes sense. Best treated as a reference implementation to borrow from rather than adopt wholesale.
A Claude Code cron routine that assembles a weekly curated report on AI agent developments. It is a working example of scheduling an agent to do recurring research and publish the output unattended. Documentation is in Korean.
A Claude Code and Codex plugin with nineteen workflows that match process to task type, keep evidence files outside your repo, and refuse to mark a claim done until an independent verifier confirms it. Pure Python standard library with no runtime dependencies. The separate-verifier design targets the common failure of agents declaring success prematurely.
A Portuguese-language AI video production workbench for Claude Code, built over the Higgsfield MCP server. The workflow uses explicit gates, a 'cold eyes' validator, and measured QC rather than accepting the first generated output.
A method for running several Claude Code agents on one repository without collisions: git worktree isolation per agent, a gate every stream must pass alone, and an evidence protocol that makes each agent's claims checkable. The merge-train framing keeps integration serialized while the work itself stays parallel.
A detailed writeup of an autonomous company built on Claude Code and the Claude API: eight agent roles (CEO, researcher, brainstormer, builder, QA, sales, marketing, finance) running an eleven-step loop on a FastAPI backend, with a Next.js dashboard streaming each step over websockets. The build step spawns headless Claude Code against a generated GOAL.md spec. Most of the setup is described as reproducible.
A Japanese-language multi-agent framework for Claude Code with four explicit roles — secretary, dispatcher, curator, and worker — each with clear responsibility boundaries. The role separation is the point: it stops one agent from silently taking on everything.
A plugin for Claude Code and Codex plus a Gemini CLI extension that keeps agents running to completion, protects data along the way, and pushes for better planning up front. Aimed at the stop-halfway failure mode on long tasks.
A Japanese-language template for writing structured documents — grant applications, papers, reports — with Claude Code under an issue-driven process. Format, evaluation criteria, and a minimal-cognitive-load serialization are settled before writing starts.
A full-cycle delivery orchestrator for AI coding agents: a mandatory intake interrogation that front-loads decisions, then ten gated stages from docs and brainstorm through deploy and acceptance. A loop guard breaks the churn pattern where an agent cycles on the same problem without progress.
A complete agentic product and project management office for Claude Code: fill in one charter, run /setup-pmo, and you get eleven specialist agents, sixteen workflows, and a methods library. Aimed at people running projects rather than single tasks.
An agentic engineering framework aimed at work that spans many sessions: idea shaper, planner, debugger, reviewer, incident responder, data migrator, and release manager all share one durable project record. The record is what lets builds survive compaction and crashes and resume mid-task.
A Japanese-language CVE triage workflow where Claude Code reads your code and narrows alerts to the vulnerable functions you genuinely use. Directly targets alert fatigue from scanners that flag every transitive dependency regardless of reachability.
A Claude Code plugin that stores task state as files in your repository, using directory location to encode status. Because the state lives in the repo rather than the session, an agent's work survives the session that produced it.
A copyable project operating system rather than a code scaffold: a work model, living documentation, and a /system dashboard derived from those docs. The distinction matters — it structures how work is tracked instead of what the app is built from.
A ten-hour experiment pitting harness configurations against each other on a vanilla-JS-to-React migration, testing whether a cheaper model as the builder in a multi-agent workflow saves tokens. It did not: orchestration overhead plus fixing the cheaper model's bugs exceeded the savings. A useful counterweight to model-routing enthusiasm.
A Claude Code subagent team splitting work by model tier: architecture and review on Opus 5, implementation and tests on Sonnet 5. Deliberately simple and long-lived, with no over-design — a concrete answer to which model should do what.
A harness for orchestrating multiple CLI coding agents — Claude Code, Codex, and others — from one place. General-purpose orchestration rather than a specific methodology.
A two-phase development lifecycle for AI-agent collaboration implemented on Nix: spec-driven during bootstrap, then guarantee-driven during maintenance. The phase split acknowledges that early and late project work need different agent constraints.
A sharp technical writeup: Claude Code places worktrees under .claude/worktrees/ inside the project root, and Node's resolution algorithm walks parent directories, so a worktree with an incomplete node_modules can silently resolve packages from the main checkout. Tests pass while the worktree's own dependency state is broken. Includes two practical checks to catch it.
A shared set of agent harness files plus an installer that sets them up for both Codex and Claude Code. Keeps one canonical configuration instead of drifting copies per tool.
A host-native control plane for AI coding agents with deterministic phases, worktree isolation, verification gates, and budgets. Runs on your existing subscription rather than adding a second API bill, which is the differentiator against hosted orchestrators.
Automates Claude Code project management against Linear: parallel workers pick up tasks, results are verified, and PR workflow is orchestrated end to end. Useful if Linear is already your source of truth for work.
A local-first workspace structure for organizing many standalone repositories on one machine, with shared caches and context derived from the filesystem layout. Aimed at people whose agent work spans a dozen repos rather than one monolith.
Automates Azure DevOps workflows with AI agents: backlog creation, sprint planning, project health checks, and work item templates. Fills a gap given how much agent tooling assumes GitHub or Linear.
A Russian-language interactive installer covering a full Claude Code setup: cross-session context, hook-enforced rules, prompt injection guards for external content, documentation freshness, and parallel subprojects with shared memory. Written in plain language with recipes and an adaptive checklist for any field.
A writeup and tool splitting generation from review: one pass produces the change, a second independent pass sees only the result — not the first pass's reasoning — and is told to find problems. Caught a silent semantic shift (inclusive bounds becoming exclusive) that self-review missed. The author is candid that both passes run on the same vendor, which weakens but does not negate the effect.
A UX designer's documentation structure arrived at after CLAUDE.md bloated into an unusable document: CLAUDE.md holds pure orientation (workflow rules, stack, file map), SPEC.md holds current documented behavior as fact with no backstory, and a decisions/ directory holds the why — evidence, rejected alternatives, dated reasoning. Splitting the why out is what keeps SPEC.md readable.
A Claude Code plugin marketplace hosting two plugins: atelier, which chains design into build into review and adds writing-craft skills, and atelier-typescript, a set of Fastify-focused skills. Install once and get the whole pipeline rather than assembling stages yourself.
A coding-agent orchestrator built on LangGraph with human-in-the-loop checkpoints, SQLite-backed resume after interruption, three-tier model routing and MCP support. Runs against Claude and Codex subscription backends instead of metered API keys.
A hub where many humans and AI agents work one repo from a shared plan. Agents claim file scopes, chat in a shared channel, and get MCP-native conflict warnings before two fast agents write the same file - aiming at zero merge conflicts.
Routes each task to one of two lanes: FAST for low-risk one-shots, HEAVY with full review gates for correctness-critical work. The choice comes from a nine danger-surface scan rather than the developer's mood, so review effort scales with actual risk.
Six NMC-anchored practice loops for nursing, each with built-in verification, escalation paths, human sign-off and an audit trail. A worked example of shipping agent workflows into a regulated profession where 'the model said so' is not an acceptable answer.
Keep one tool-neutral .ai workspace in the repo and compile it into the runtime artifacts each assistant expects. Avoids maintaining parallel config for Claude Code, Cursor and everything else by hand.
A delivery conveyor for Claude Code and the Codex CLI that runs investigate, decompose and deliver as distinct stages, one git worktree per ticket, with mechanical gates and PRs driven to green. Ships with the reproducible container it runs in.
A Dispatcher reads YAML task definitions and assigns them to parallel Workers running Claude Code or the Codex CLI in tmux panes, reporting progress through dashboards. Plain-text, inspectable orchestration with no extra daemon.
A Korean-language kit that folds several AI subscriptions into one development pipeline: Claude or Codex act as the supervising harness for planning and review, implementation is delegated to opencode, with fallback across subscriptions as quotas run out.
A solo founder has Claude Code write specs and build features, then Codex audit both and return GREEN, YELLOW or RED. One hard feature burned five spec versions and four RED audits in a single day - and the findings were mostly real, which is what makes it hard to stop. A useful cautionary case on where second-model auditing stops paying for itself.
An orchestrator for AI coding-agent workloads that runs local-first, keeping scheduling and state on your machine rather than in a hosted control plane.
Turns Claude Code sessions into a team of equal, long-lived peers sitting at a round table - no supervising orchestrator dictating work. A structural alternative to the usual dispatcher-and-workers pattern.
A specification-first workflow aimed at the communication gap between humans and LLMs: write the spec the agent works from, so intent is explicit before any code gets generated.
Puts the whole development record in GitHub: a requirement is an issue, a decision is an approval comment, work is a PR and rationale lives in that PR. An orchestrator relays the conversation to GitHub and spawns sandboxed role sessions, each given only its own rulebook.
Frames the coding-agent shell as a Michelin-star kitchen where you are the boss: nothing leaves the pass until Jeff signs off. In practice a review gate sitting between agent output and anything downstream.
To stop an autonomous loop from grading its own homework, the author pre-registered three builds from empty folders: the first commit in each repo fixed the goal, the operating envelope and a verify command naming an external judge the loop cannot edit, so the git log proves the gate predates the work. One target was a TOML v1.0 decoder in Rust judged by toml-test v2.2.0; for another the spec was mutated so memorized answers would fail.
A full development pipeline for Claude Code driven by a single set of commands: brainstorm the idea, write the spec, break it into tasks and take it through to a merged PR.
A multi-host plugin that gives a repository a single explicit engineering workflow driven by the change being made, and keeps that workflow identical whether the session is Claude Code, Codex or OpenCode.
Keeps planning and task state in the repository as focused markdown 'planlets', driven by a deterministic CLI plus portable agent skills. Plans stay reviewable in git instead of living only in session context.
A preregistered benchmark ran repowise, CodeGraph, Serena, Graphify and a no-tools baseline over 48 Django questions from SWE-bench, same agent/prompt/commit, 261 runs total. Best result was ~32% fewer output tokens per question, far below the 60-90% savings these tools advertise, and index build times varied from 16s to 367s. Harness, raw data and invalidated runs are public; the author discloses working on one of the tools benchmarked.
A local orchestrator for Claude Code that lets you drop a task into a queue and walk away. It dispatches work across multiple concurrent sessions and pushes notifications when runs finish, so long jobs do not need babysitting. Python-based and self-hosted, aimed at fire-and-forget agent workflows.
One user's orchestration setup where the main loop only plans, decomposes, dispatches, and reviews, while a roster of subagents does the work — a reasoning model for adversarial review and root-cause, a strong coder for open-ended specs, a cheaper model when the spec cites an existing pattern, and a small model for mechanical sweeps. Includes a concrete inline-vs-dispatch gate and the rule that plans state contracts and verification steps rather than finished code. Each phase runs in a clean session.
A starter kit for Software as a Medical Device projects, scaffolding IEC 62304 and ISO 14971 compliance from day one. It ships ten specialized agents, multi-agent workflows, and generates a complete regulatory Design History File. A rare example of agent tooling aimed at a heavily regulated engineering domain.
A development toolkit that wraps Claude Code with context engineering and agent orchestration. It covers the arc from ideation through auto-resolving issues to shipping. Aimed at people who want an opinionated end-to-end flow rather than assembling their own.
Context files, rules, skills, hooks, and memory conventions extracted from a working agency and packaged as a repo. It treats business operations, not just code, as the thing the agent maintains. The value is in seeing conventions that survived real day-to-day use rather than a theoretical setup.
A deterministic, observable spec-driven development harness for AI coding agents. Work moves through enforceable gates that produce auditable evidence, and delivery stays under human control. Useful if you want repeatable agent workflows rather than ad-hoc prompting.
A Claude Code plugin for governed, spec-driven delivery. Acceptance contracts are frozen up front and a merge floor refuses to let a red seam through, so an agent cannot quietly redefine done partway into the work.
A portable quality gate kit you can drop into multiple projects to hold Codex and Claude Code to the same standards. Useful when you maintain several repos and want one consistent bar.
Captures your Claude Code working context, runs /clear, then restores it automatically. Reclaims the context window mid-task without the usual cost of re-explaining where you were.
An empirical check on the claim that vibe-coded apps leak secrets. Cloning 63 real AI-built web apps turned up 4 committed privileged credentials, roughly 6 percent, and none of them were sitting in .env, which is where most scanning advice points. A useful correction to both the panic and the standard mitigation.
Takes work from brainstorm to PR through six stages with five evidence-gated transitions, so no stage advances on assertion alone. Drives from Claude Code or Pi.
Handoff docs between long-running sessions go stale and a fresh session believes them anyway. This protocol adds one rule most versions skip: anything bold or load-bearing that is more than about a week old gets checked against git before it is trusted again.
A pipeline that takes a tracker ticket and runs it through eight distinct agent roles until it emerges as a reviewed, QA-verified pull request. Ships as a plugin for Claude Code, Codex, and Cursor.
A companion layer for BMAD aimed at cleaner builds, updated in v4 to let agents fan out and build in parallel where the code structure allows it. Relevant if you already run BMAD-style planning.
A developer with 35 years of reviewing code describes the workflow — TDD, instructions, hooks, and sweeps — that finally let them stop second-guessing whether the agent's output was sound. Written up around real open-source home security work rather than a toy project.
A structured workflow system for AI coding agents that combines harness engineering, an execution loop, skills, hooks, and a learning loop that feeds results back in. Works with Claude Code, Codex, Antigravity CLI, and Copilot.
Adds a vendor-objective solution designer, GCP and agentic architects, security, SRE, and QA roles, wired into a design-first and security-first delivery gate. Installs on Claude Code, Antigravity, Codex, and Kimi.
A delivery team of coding agents where Temporal owns durability of the job, Claude Code makes the judgment calls, and team folders hold the governance. Every claim is measured, tested, and published rather than asserted.
A solo SaaS developer realized their project's context, decisions, and conventions all lived inside one Claude account, and restructured so any fresh agent can start from the repo alone. Two findings stand out, chiefly that stale docs are worse than no docs because a contradicting doc makes a fresh LLM confidently wrong.
Runs a larger model over a smaller model's daily output to critique it and feed improvements back in. A cheap way to keep a low-cost agent honest without paying frontier prices for every turn.
A development-methodology plugin for coding agents that covers the chain from design through completion as skills, and forces the agent into that chain at the start of every session. Documentation is in Korean.
A full-tunnel VPN that the coding agent needs breaks the app under development when domestic services reject the foreign exit IP. The fix is not a static route, since those are global and pull the agent off the tunnel too, but per-socket binding with curl --interface and the equivalent in your stack.
Three rounds of controlled agent walks over a markdown vault, hand-graded from raw traces across four conditions including mapped, blind, and filesystem-only. The honest result is that plain filesystem navigation beat the elaborate map-and-contract protocol, and self-reported agent success turned out not to count as evidence.
A plugin that adds multi-agent orchestration to Claude Code. Small and focused rather than a full framework.
Verified knowledge transfer across /clear: the outgoing session writes control questions, the incoming session answers them after reading everything, and the outgoing session grades the answers until it can honestly print the green light. Turns handoff from an assertion into a test.
The argument is that models cannot know what they need until they look, and looking drags in a large amount of material that is never load-bearing for the answer. Pruning roughly half of what Claude Code sees reportedly makes it work better, not worse.
Agents implement plans well but define them badly, so they rush to generic templates and start editing files before you have agreed on anything. This open-sourced tool forces a dynamic alignment exchange with you before implementation begins.
An educational write-up on prompt structure and setting up context inside the prompt itself, using a real failure — someone asking Claude to merge two large open-source monorepos — as the worked example. The argument is that structure matters less than actually thinking the task through and writing it down clearly.
Data from an AI delivery factory splitting load between Claude and GPT subscriptions points at orchestration being the single largest consumer of available usage, and at the orchestrating model's choice having outsized impact on outcomes. Downgrading the orchestrator from a frontier model changed the economics substantially.
Five review agents were asked to break SQLite trigger logic and confirm tests went red. All five returned a confident reading, none errored, and not one said it could not run anything. Re-running with an agent that actually had Bash surfaced two integer overflow gaps and a whole direction the reading had never considered.
An eight-stage orchestrator skill for Claude Code and Codex that takes a Figma parent frame and drives it through to a shipped SwiftUI + TCA feature. Each stage is a discrete step with its own checks rather than one giant prompt. Narrow but deep if you work in that stack.
A three-week experiment where Claude Code was given cluster admin and a standing goal to make money autonomously. It built graded.sh, an index of ~3,500 x402 pay-per-call APIs that it probes every six hours and grades A–F, plus a gateway, and it operates the deploy pipeline and its own Grafana dashboards. An unusually concrete look at long-horizon autonomous operation.
A scaffolding kit that drops structured multi-agent workflow definitions into an existing codebase without tying you to one provider. Gives you the harness — roles, handoffs, checks — rather than a fixed pipeline. Useful as a starting skeleton.
Defines contracts up front so multiple coding agents can build in parallel without colliding, then holds the output to engineering release standards. Targets the gap between agent speed and shippable quality. Process-heavy by design.
Workflows, presets, extensions and bundles that extend GitHub Spec Kit beyond its defaults. Lets you adopt spec-driven development without writing the scaffolding yourself. Community-maintained.
Covers the full lifecycle for one person directing agents: project bootstrap, product discovery, phase delivery, review orchestration, verification, and evolving the workflow itself. Opinionated about the human staying in the director's seat. Broad but coherent.
Builds a mostly-autonomous development workflow out of native Claude Code primitives — hooks, skills, GitHub Actions — rather than introducing a new engine. Explicitly a convention and configuration layer, so there's less to break when Claude Code changes. Attractive if you distrust heavyweight frameworks.
A local-first, git-native daemon that orchestrates external AI coding agent CLIs through discover, plan, implement, verify and deliver, ending at a pull request a human reviews. Keeps the agent loop running without keeping you in it. Everything stays on your machine.
Uses Claude Code as a supervisor that assigns tasks to other AI coding agents, reviews what comes back, and sends sloppy work around again. A manager-of-agents pattern rather than a single-agent loop. Light on detail but the shape is clear.
Argues that reviewing the plan is dramatically cheaper than reviewing the code, that the planner shouldn't review its own plan (same model, same blind spots), and that the reviewer shouldn't be allowed to rewrite it either. The proposed loop: the original agent investigates each finding and must defend or revise. A concise case for review-before-code.
A PM agent dispatches role-bound workers through a critique and verify loop, and every artifact ships with execution evidence bound to a git SHA. The design goal is that approval reflects a run that happened, not a plausible-looking answer. Installs as a drop-in .sagan/ overlay in any repo.
A control plane that sits in front of Claude Code and Codex, gating work behind dependency-aware readiness checks and scoped execution. Runs 25 engineering 'lenses' over the result and produces fingerprinted evidence for human approval. Aimed at teams who want agent output reviewable before it lands.
You brief leopold the way you would brief a teammate and it conducts Claude Code sessions in your seat. Git operations stay locked so the harness cannot commit or push on its own, keeping the blast radius bounded during unattended runs.
Lets you design coding-agent workflows by hand, review them before they execute, observe them while running, and trace them afterward. Deliberately provider-neutral - it drives Claude Code, Codex, Gemini, Copilot, or any CLI agent.
An AI-native engineering setup combining LLM knowledge management, verification grounded in a project wiki, RFC-based documentation, and automated best-practice enforcement. Aimed at keeping agent output anchored to written decisions.
An open protocol that decomposes 'idea to shippable system' into 12 primitives across 8 phases, designed to run on Claude Code. The pitch is coherence and ownership: the output is a system you understand rather than a pile of generated files.
A full development platform for Claude Code: long tasks that survive context limits via automatic handoff, prompt optimization, skill and agent creation, quorum-based code reviews, project rule management, and knowledge persistence.
The /guardian command scans a repo for security, performance, and architecture issues, shows proof for each, then loops fix-verify-rescan until clean. Includes payment idempotency fuzzing and an anti-cheat gate that catches agents faking test passes. Works in Claude Code, Cursor, Codex, OpenCode, and Kilo Code.
Treats a product initiative as continuous tracked work rather than a series of one-shot prompts: persistent state across sessions, a living PRD, and hypotheses typed by the kind of evidence behind them.
Cleans up the debris AI workflows leave behind without discarding the knowledge in it: audit first, update documentation, then quarantine rather than delete. The quarantine step makes the cleanup reversible.
A multi-agent production framework for building Three.js vertical slices in game development, where each stage has to produce evidence before the next one proceeds.
Turns a repository request into an approved plan, then DAG-scheduled routes with bounded execution and reviewable evidence at the end. Harness-agnostic and local-first, with approval and review authority deliberately kept by the repo owner.
Argues that with newer models the depth of your test suite matters more than the prompt. The author's routine: keep an unusually thorough Playwright suite, let a wide-open session refactor on a throwaway branch, then port only the ideas worth keeping onto dev through controlled sessions.
One builder's answer to the absence of a canonical agentic workflow: a markdown brain holding rules, a todo queue, and a ranked backlog of future ideas, plus a weekly automated analysis of past chats that enhances the system itself. Aimed squarely at preventing rabbit holes that do not advance the goal.
Memory notes accumulated until the agent was confidently repeating things that were no longer true. The fix was one long-term fact per file, with dates written out in full because 'last week' is meaningless when the note is read three months later.
An orchestrator setup laid out end to end: three top-tier models each produce a plan, an independent instance synthesizes an unbiased best version, and the finalised plan goes to cheaper worker agents for execution. Useful as a concrete reference point if you are assembling your own multi-model pipeline.
Lets Claude Code delegate reviews, tasks and rescue jobs to Codex and Cursor running as background workers. Jobs are tracked with live progress and session handoffs between agents. A concrete take on cross-vendor multi-agent work.
A written contract covering how to run an agent-built project from kickoff through App Store release to sunset. Deliberately not a framework — no code to install, just process. Targets Claude Code, Codex and Cursor equally.
Claude crawls your site wearing 15-plus reviewer personas, runs findings through a three-gate review, then applies minimal fixes and stops on its own when done. It also revises its own workflow between rounds. An unusually complete example of a self-terminating agent loop.
A practical playbook for structuring mixed AI-and-human teams around production software delivery. Focuses on team organization and process rather than tooling. Useful reading if you are scaling agent use past a single developer.
Locks a brand definition, generates UI through that mold, and mechanically refuses anything off-system before it ships. Replaces subjective design review with a pass/fail gate. Aimed at agent-generated UI drifting away from the design system.
A working build pipeline of design-swarm, run-list and conductor stages, with probe-verified execution between them and a swappable config layer. Presented as skills actually in use rather than a demo. Good reference for staged orchestration design.
Tooling for keeping a large fleet of agent-authored PRs moving without a human watching each one. The author claims 150-plus PRs a week as the target throughput. Aggressively opinionated about where human attention should go.
After 41k agent-written lines, the author dropped the keep-ARCHITECTURE.md-current approach for a small doc holding only what the code cannot express: glossary, invariants and decisions. Code and data model stay the source of truth, so the doc never goes stale. One month of evidence, presented as a question rather than a claim.
Three months of real numbers from an agent that reads logs and traces to write root-cause summaries into Slack: 7,364 investigations, $4,458 in tokens, median run $0.43 across 16 tool calls. The thread asks where the fat actually is in that shape of workload. Concrete cost data is rare enough to be worth reading.
The idea: send a trivial prompt just before the cache TTL expires so a large context never has to be re-read at full price. Would enable long-lived, heavily-preloaded sessions for near-zero upkeep. Posted as an untested proposal, with the thread weighing whether it holds up.
A plugin marketplace entry that flips the default: Claude refuses to build until it knows who actually asked for the thing. In the author's own test it closed its own pull request. Installed via the plugin marketplace and framed as a challenge to try.
Argues CLAUDE.md becomes a junk drawer because it mixes three scopes: rules that should always load, one-off incident lessons that should not, and cross-project workflows trapped in one repo. Proposes splitting by scope so only repo-level rules stay resident. Written by someone building a memory tool, and says so up front.
A developer running three parallel Claude Code sessions built a shared system where agents publish interface contracts so others are warned before writing against stale API shapes. A sharper critique they received: contracts should be derived from source (extracted signatures on save) rather than self-declared, since a forgotten declaration fails quietly while still looking trustworthy; declaring still matters for cross-machine coordination before anything is committed.
Drop foureyes into any repos .claude/ directory and run /bootstrap to get a structured pipeline: discovery, spec, plan, then code. Aims to slow Claude Code down just enough to avoid skipping straight to implementation without a plan.
stem adds process discipline to coding agents: sizing tasks, keeping every change on record, verifying output against original intent, and preventing lost sessions. Works across Claude Code, Codex, Cursor, and Gemini CLI.
A workflow pattern for handing off in-progress coding-agent work across Codex, Claude, Pi, and other harnesses without losing state. Aimed at teams mixing multiple agent tools on the same task.
A generic software-delivery workflow pattern for coding agents: a single /autopilot command runs orient, plan, critique, implement, review, test, ship, and finish. Ships as harness-neutral specs with generated adapters for Claude Code and OpenCode.
A Reddit tip warning that if you use Fable to spawn subagents on lesser models with concurrency limits, you should never mention your 5-hour usage window to it. Doing so can trigger a safeguard that halts work until you switch to Opus, tainting context and forcing a restart.
A production postmortem showing per-call cost is not fixed: median runs cost $0.43 but the tail (50-128 tool calls) costs far more per call, since every turn resends the full prior context. The real driver of expensive runs was poorly instrumented services forcing the agent to search longer, not task difficulty.
AMH provides a memory hierarchy, a verification ladder, and reusable workflows for repos that coding agents maintain over time. Aimed at keeping long-lived, agent-touched codebases consistent and verifiable across sessions.
FlowCrew orchestrates a planning agent, parallel coding agents, and QA gates on top of Claude Code or Codex from a single brief, with a persistent campaign memory meant to improve across runs. Aims to let you hand off a task and walk away.
A write-up and accompanying docs (workbench-101, lessons-with-examples, workflow-mechanics, auto-mode-rulebook) from someone who spent months offloading most development work to agents. Covers concrete guardrails and lessons learned for running agents with minimal supervision.
An MIT-licensed governance harness for Claude Code that combines blocking enforcement hooks, routed coding standards, and multi-project trackers with resume points, aimed at keeping agent work within agreed constraints across sessions.
A task board paired with a pool of sandboxed coding agents that pick up and work tasks, plus a manager agent you talk to directly. Useful for teams wanting a lightweight way to fan out coding work across multiple isolated agent workers while keeping a single conversational point of control.
A human-steerable local CLI that orchestrates native Claude Code and OpenAI Codex sessions side by side, with explicit routing rules, persistent handoffs between the two, and review workflows designed to keep a human in the loop. Aimed at developers who want to combine both agents' strengths without losing control over what gets executed.
A local BM25F lexical ranking pass over file contents, names, and directories generates a shortlist of likely-relevant files before a coding agent starts grepping a codebase. Benchmarked on 240 real SWE-bench Lite issues across six repos, it puts the correct file in the top 20 results 77.9% of the time with no embeddings or API calls. Excluding in-repo documentation from the ranking was the single biggest accuracy gain, lifting MRR from 0.383 to 0.475.
Agent Pingu is a structured development loop for Claude Code built around lanes, phases, and enforced gates, backed by a persistent vault. Four independent blind reviewers check work at each gate before it can proceed, aiming to catch mistakes a single self-review would miss.
A lightweight project documentation template built for AI agents — structured START/STATE/TODO/DONE files, workflows, and tooling that give an LLM persistent, easy-to-parse project memory across sessions.
A technique for avoiding mid-run stops from 5-hour session limits: poll the statusline, pause new work at 90% usage and new agent spawns at 80%, then resume once the window resets, letting overnight runs continue without interruption.
A stack-agnostic blueprint for integrating Claude Code into a Jira/agile engineering workflow, covering semantic code navigation, durable memory, and multi-agent flows behind slash commands.
Running Claude Code in a shared multiplayer session with a second person reviewing each other's turns solved approval fatigue better than solo manual-review or accept-edits mode — each person reviews the other's diffs without the self-approval bias of reviewing their own prompts.
Reads what your project actually does, proposes the smallest team of agents that could do the work, and "hires" them once you approve — each with a handbook, a pinned model, and a check it must pass.
A toolkit for multi-session Claude Code work: cross-session messaging, claims/locks so two sessions don't grab the same task, a worktree gate and reaper to stop sessions from clobbering each other's branches, a hook-install checker, and a number allocator for sequentially-numbered docs like ADRs.
A technique for keeping Claude Code from silently converting ambiguous requirements into assumptions: before implementation, sort every unknown into a human decision (stop and ask), a testable fact (investigate and cite evidence), or a reversible default (choose, but state the choice and how to undo it) — with any unresolved human decision required to stay visible in the final plan.
Runs Claude Code, Codex, Gemini CLI, or any OpenAI-API-compatible agent through an 18-stage development pipeline, with artifacts and gates tracked on disk rather than buried in a chat log.
cc-autoship turns Claude Code's development work into a traceable, reviewable asset on GitHub by capturing it as issues, PRs, diffs, and reviews. Aimed at teams that want an auditable paper trail for AI-driven changes.
A Reddit tip describing how to run multiple parallel Claude Code sessions on a beefier remote machine using VS Code Remote SSH instead of upgrading your local PC. Simple, concrete workaround for RAM-constrained machines running several agent sessions at once.
A workflow enforcing red-first TDD, self-tested gates, calibrated independent verification, and commit-bound evidence for coding agents. Aims to give teams confidence that AI-written code actually passed real checks before merging.
kilin is a local, CLI-first runtime that lets you describe a workflow in plain files, validate it before running, then execute it through Codex, Claude Code, or OpenCode with explicit approvals and persisted run history. Useful for making agent-driven workflows repeatable and auditable instead of ad hoc.
An essay arguing that as AI coding moves to multi-agent workflows, chat history is a poor substitute for real engineering artifacts like ownership boundaries, dependencies, and file-scoped responsibilities. Describes a concrete pattern (a TESTER agent owning test structure while a FIXER agent handles bugs, coordinated via explicit boundaries) drawn from a year of multi-agent experiments.
A Reddit post describing why browser agents fail silently (e.g. scraping the wrong table after a layout change) and how switching from re-prompting the agent every run to letting it discover a workflow once and saving it as a reusable command (using a tool called WebCmd) made results far more trustworthy. Useful technique for anyone running recurring browser-automation tasks with AI agents.
paper2pr is a Claude Code multi-agent workflow that converts an AI/ML paper into presentation-ready Beamer and Quarto slides. Useful for researchers who need to quickly turn a paper into a talk without manually building slides.
A multi-agent code review workflow where a committee of specialist reviewer agents adversarially critique code, aiming to catch issues that single-pass AI review misses. Useful pattern for teams wanting more rigorous automated review with Claude Code.
An operational-hardening playbook documenting the stdin deadlocks, silent empty reads, SQLite races, and truncated outputs that hit when driving CLI coding agents headlessly and in parallel, each with a one-line fix. Useful reference for anyone automating agent CLIs in CI or scripts.
A numbered, file-based work ledger checked into the repo so concurrent Claude Code / multi-agent sessions can file, claim, and close tasks on the record, avoiding collisions between parallel agents working the same codebase.
Extends Claude Code with domain-specific agents and reusable skills, plus enforcement logic that routes edits of owned files to the right specialist agent automatically. Aimed at keeping large multi-agent setups organized and on-spec.
A Claude Code-native framework that takes a meeting recording and turns it into a deployed Salesforce Agentforce service agent, complete with an in-app feedback loop. Niche but shows an end-to-end pattern for turning requirements capture directly into a deployed agent.
A Japanese-language framework that lets AI agents like Claude Code safely handle document management, research, meeting minutes, and design-doc creation within defined guardrails. Aimed at teams wanting structured, auditable agent workflows for knowledge work rather than ad-hoc prompting.
A harness for running coding agents (Pi and Claude Code) under spec-driven development and OpenSpec discipline, aiming to keep agent output aligned to a written spec rather than free-form prompting. Targets teams wanting more structured, spec-first agent workflows.
A comprehensive suite for Claude Code combining multi-agent 'ultracode' workflow scripts, a workflow-authoring skill, a live-progress statusline, an enhanced observation UI, and validator/diagram tools. From a known contributor in the Claude Code tooling community (curator of awesome-claude-code), suggesting solid execution.
A multi-agent software development framework designed to maintain quality under a single-model constraint, using fact-sourced documentation, nine opposing role-based goals, executable gates, and multi-model review. Argues that structured process, not raw model capability, drives reliable output in agentic dev workflows.
A workflow where an article on agent-graph design patterns was fed independently to Claude Code and Codex to audit the same repo, then only the recommendations both models agreed on were implemented. The process used a read-only 'Explore' subagent for inventory and an adversarial evidence-reviewer subagent, and it surfaced a real governance bug along the way — a technique for reducing single-model bias in architectural decisions.
A framework for chaining coding agents together through hand-offs and loops so multi-step work can continue running without direct supervision. Positioned as infrastructure for building longer-running, multi-agent coding pipelines.
A free, Apache-2.0 licensed Claude Code and Codex plugin that runs a growth-strategy pipeline for bootstrapped founders: competitor analysis, a buyer jobs-to-be-done map, and 7-9 unconventional acquisition tactics, in about 90 minutes, fully local. An example of using Claude Code plugins for non-coding business strategy work rather than software development.
A live public cluster where Claude Code sessions from different owners collaborate on one shared crypto-trading codebase — agents propose hypotheses, run backtests, and critique each other's results in the open, with a public dashboard and repo anyone can fork or connect an agent to.
A workflow for running Claude Code unattended overnight with a single structured prompt — /goal improve {target} in {scope} from {baseline} toward {goal state}, without {constraint}, until 8am — on a throwaway branch with no push credentials and a spend cap. Requires a mandatory morning report covering the starting number, ending number, reasoning, and next recommendation.
A researched breakdown of Anthropic's prompt-caching mechanics (write/read multipliers, what counts toward ITPM) and a clear explanation that these API-documented facts don't automatically apply to subscription (Pro/Max) usage limits, which Anthropic doesn't document — correcting a common conflation seen in community answers.
A scheduled daily prompt that uses Claude Code Desktop's session-management MCP tools (list_sessions, list_events, set_session_title) to rename sessions whose auto-generated title no longer matches what the conversation became, only renaming on clear mismatches within the past 24 hours.
A workflow for making Opus 5 reliable by running it in a loop against a lightweight dev framework that tracks projects, tasks, and evidence, capped at 3 internal pre-reviews and 4 review-service submissions before a human is paged. A separate Fable session monitors Opus's failed sessions, rewrites its skills/rules, and sometimes finishes the stuck task itself.
Explains why context engineering matters from first principles: LLMs are stateless, agents fake state by re-pasting the whole conversation array each turn, and attention degrades as context grows with no clean drop-off point (citing Lost in the Middle). Works through the practical implications for structuring prompts and managing context in Claude Code.
A supervisor script that builds a software specification into a finished product using Claude Code, looping over a to-do list until each item is implemented, committed, and checked off. Multiple instances can claim to-dos in parallel, synchronized through the git repository.
A Claude Code plugin marketplace bundling two independent plugins: a developer day-loop workflow and a gated test-driven-development build pipeline. Aimed at enforcing TDD discipline in agent-driven coding sessions.
A Claude Code plugin that orchestrates task classification, live documentation, a design gate, layered security checks, and model routing. Aims to be a single entry point coordinating an entire development workflow.
An experimental self-improvement harness for Claude Code, ChatGPT, and Codex featuring memory-aware startup, safer tool use, verification hooks, bounded fresh-context delegation, a deterministic task-graph runtime, and session closeout.
An agentic workflow that fetches YouTube transcripts, generates deep summaries via Claude, and uploads structured blog posts to Notion with full metadata. Automates turning video content into written posts.
A structured six-step coding workflow for Claude Code — Plan, Review, Finalize, Code, Deep Check, Audit — runnable all at once or step-by-step, with the ability to switch models between steps.
A kit for agentic IDEs (Claude Code, Antigravity) to build a content agent that crawls sources, writes drafts, gates them through a review step, and publishes to social platforms via Make.com. Includes a 9:16 video pipeline with voiceover, B-roll, and web screenshots. Zero dependencies, environment-variable only, MIT licensed.
A GSD Core capability making OpenSpec the normative requirement source for the GSD phase loop, blocking shipping until the implementation is proven to satisfy the spec.
Runs one AI agent as the orchestrator of an entire workspace inside the Orca ADE, using only a CLI subscription — no API key or model endpoint. Orca hosts and places every session; the harness dispatches workers under contract, verifies their output before accepting it, and hands the orchestrator role to a fresh session when context runs out.
A self-healing agent framework for Claude Code covering the full SDLC/SSDLC with 13 specialized agents, 26 skills, 13 slash commands, and 9 hooks. Includes a launchd watchdog daemon and observability dashboard for auto-activating, drift-reconciling, snapshot-protected automation.
A pack of eleven rigorous workflows for Claude Code, Codex, OpenCode, and Pi covering code review, security audit, feature development, frontend design, and MCP tooling. Portable across multiple coding agents.
A developer replaced manual prompting with scheduled Claude cloud routines: one daily routine reviews the codebase and CI to manage GitHub issues, and two-plus daily routines work open tickets through to PRs. The result is a closed loop -- tickets to tests to features to verification to PR to CI to new tickets -- with the human only approving PRs.
A macOS daemon that queues Claude Code tasks and automatically runs them as your 5-hour session limit resets, spreading work across windows so you don't have to babysit the cap manually.
A workflow pattern for unattended Claude Code runs against Excel/VBA: the agent works on a throwaway workbook copy, writes and imports each module, and runs a self-test before promoting it to the real file. Includes automatic Excel crash/hang recovery so the loop can run overnight without supervision.
A vendor-neutral agent operations harness that adds a .agent context layer, an LLM wiki, GSD-style planning, and loop engineering, wired into Claude Code, Codex, and Cursor via hooks. Designed to drop into either a greenfield repo or an existing codebase in a single setup step.
A persistent spec-to-ship workflow for Claude Code aimed at solo developers working in repos only they read, trading the ceremony of team-oriented workflows for a leaner 'thin lane' process.
A workflow that splits agentic coding across two models: Claude Code handles planning and review while Codex handles implementation, aiming to combine each model's relative strengths instead of relying on one agent for the whole loop.
A local-first governance layer written in plain Markdown for coordinating Codex, Claude Code, and other AI coding agents working in the same workspace, aimed at keeping multi-agent setups from drifting out of sync.
A cross-agent coding harness for Claude Code, Codex CLI, and Gemini CLI built around one shared skill canon, mechanical safety gates, and an autonomous loop with live progress/ETA reporting and proof artifacts for each run. Published to npm as @hecer/yoke.
A local-first CLI for running structured engineering loops with Codex, Claude, and OpenCode, incorporating PR review feedback, verification steps, and safe commit boundaries so agent-driven changes land in controlled increments.
A hierarchical engineering-loop system with machine-checkable proof gates, aimed at the common failure mode where an AI coding agent claims tests pass without actually running them.
A development framework that splits work between a Design agent (Alex) and an Execute agent (Blake), enforced by a 4-gate quality system and backed by 25 capability packs covering different domains.
A component-datasheet-style writeup of token-saving techniques for Claude Code and Codex, with measured before-and-after figures that refresh daily. Source for savetokens.tips.
A herdr plugin that keeps git worktrees and agent workspaces in sync — starting an agent on an issue in its own worktree, then reconciling `git worktree list` against herdr's known workspaces to adopt orphans, staff empty ones, and remove finished checkouts. Resumes Claude Code sessions from existing transcripts rather than restarting them.
A structured workflow for Codex and Claude Code that takes a web design from interview through a DESIGN.md spec, a build phase, independent review, and deterministic QA, with approval gates between each stage.
A harness-agnostic protocol for greenfield projects that starts from a rigorous concept rather than a chain of ad-hoc prompts, so agents build from shared intent. Includes self-healing and crash-safe state handling.
A Claude Code plugin that runs Google's Antigravity CLI (Gemini) as a collaborating sub-agent, with intelligent model routing across different phases of the SDLC. Unofficial community project.
A sprint/epic/story planning protocol for Claude Code agents built around a four-agent loop -- architect, developer, qa, and reporter. Includes a Karpathy-style awareness wiki to keep long-running agent teams oriented across a project.
A Reddit user shares their workflow for large AI-generated projects: an ENGINEERING doc of coding principles enforced by an architect subagent and a hook, plus a cascade of ARCHITECTURE, PLANNING, phase, and PROGRESS docs that keep long unsupervised builds on track.
A framework for organizing Claude Code, Codex, and Devin into an autonomous company structure -- a charter, 30 defined roles, SOPs, and cross-platform adapters for coordinating many agents on real work.
A planning framework that persists context across sessions so multi-phase work can be planned once and executed by any agent -- Claude Code, Codex, or OpenCode -- without losing the thread between sessions.
A solo developer converted four CLAUDE.md rules that kept getting silently dropped between sessions into scripts wired into npm run build, so violations fail the build instead of relying on the model remembering. Covers guards for email HTML fallbacks, price consistency, retired product copy, and an HTML sanitizer allowlist, each one only allowed to grow stricter over time.
A template repository for agentic coding projects, built around a hash-pinned AGENTS.md "kernel" and a single check.sh gauntlet that's mirrored in CI. Includes a memory system that learns from external signals and forgets on a schedule, and targets Claude Code, Codex, and any AGENTS.md-reading harness.
A proportional planning, recovery, and engineering-discipline protocol for coding agents, designed to work across Codex, Claude Code, Qoder, and OpenCode. Aims to keep agent effort scaled to task size and recover gracefully from failures.
A self-driving agent loop for Claude Code that turns an issue into a planned, verified, and committed change end-to-end. Lets you run, supervise, and chain multiple workplans from the shell for more autonomous delivery.
Orchestrates Claude Code and Codex CLI subagents behind an Architect role that plans work as one issue per task with model/effort/reviewer assigned, then spins up a branch and worktree per issue for an Implementer or Specialist, followed by automated review and CI. Merges run pinned to the approved commit and fail closed if the PR changes after approval.
Provides durable work sessions for coding agents using isolated Git worktrees, an append-only history of what happened, and explicit merge outcomes. Aimed at making long-running or resumable agent sessions easier to audit and recover.
Runs unattended Claude Code sessions overnight that work through a TASKS.md queue and turn each item into a reviewable pull request. Aimed at "leave it running while you sleep" style batch task processing.
ccgrapher lints agent workflow plans for joins that pass while a branch is actually dead, and for verifiers that end up grading their own work. It also finds every plan step that isn't actually waiting on anything, and runs those independent steps in parallel. Ships as a Claude Code skill (parallel-plan) that checks a plan's real dependencies before the agent executes it.
Runs a simulated company inside Claude Code as a recurring tick loop, with role-based subagents, human approval gates on anything touching money or outreach, and an append-only ledger for auditing what happened.
A repository template for Nx monorepos that ships with governance rules, AI agent/skill scaffolding, three-level testing, and 11+ language backends pre-wired, so new repos start with working conventions instead of a blank slate.
Packages a coding-agent delivery methodology as installable kits — spec consistency checks, an evidence-stamped iteration lifecycle, and token-aware context management for keeping long agent-driven projects on track.
An agentic workflow for repo-capable AI agents that captures screenshots, inspects the visual evidence, and gates a business-grade design review report — instead of an agent guessing at how a page looks.
Structures agent-driven research as resources → ideas → human approval gates → bounded experiments → audited claims. Ships as a Claude Code plugin and portable skill — a test-first generalization of karpathy's autoresearch.
Implements the "ralph" pattern — a generator/evaluator loop — to orchestrate Claude Code, OpenAI Codex, and GitHub Copilot across multiple repositories for long-running, semi-autonomous coding tasks.
An open-source workflow where one Fable agent orchestrates four Opus agents and a GPT agent across five git worktrees — picking up GitHub issues/PRs, dispatching implementation work, routing blockers to a specialist investigator agent, and reviewing/merging the results itself.
A local-first automation framework (also known as llmauto) for chaining autonomous Claude Code agent runs together. Aims to let multi-step LLM workflows run unattended on your own machine.
Spins up an already-running Claude Code session in its own git worktree for each ticket pulled from Jira, Linear, GitHub Issues, Shortcut, or Asana. You review the diff and merge — no manual session setup per task.
Reference implementation of Cross-Lab Adversarial Review (CLAR): runs a different AI lab's model as an independent code reviewer, then verifies, reconciles, and escalates only real disagreements.
A three-agent Claude Code pipeline that strips secrets from a private repo, verifies the sanitization, and generates professional docs before publishing. Triggered with a single /opensource command.
The author's actual production setup for shipping with Claude Code — rules, hooks, subagents, and patterns bundled as a reusable 'AI operating system.'
A technique for extracting behavioral rules from session history: only patterns that recur across at least two separate sessions become rules, sorted into layers for working style, design taste, writing voice, and editing habits. Tested head-to-head against a plain CLAUDE.md on the same task with a visibly different result.
A Claude Code plugin for spec-driven multi-agent orchestration with 13 agents, 35 skills, per-phase model tiers, opt-in lifecycle hooks, and optional cross-device semantic memory.
A Claude Code plugin marketplace bundling adversarial project reviews, task workflows, GitHub release automation, and in-browser HTML visualizations.
Production-grade playbooks covering the full software delivery pipeline — 21 playbooks, 10 agent skills, 4 specialist 'guardian' agents, and 5 runbooks from discovery through operations.
Interview-driven planning followed by execution across haiku/sonnet/opus-tiered agents, with an adversarial review chain that verifies changes through real usage rather than just reading the diff.
Structures documentation as code with linting and agent workflow adapters for Claude, Codex, Cursor, and GitHub Actions.
Decomposes a backlog into PR-sized units and dispatches one autonomous Claude Code lead per unit across local, SSH, or cloud hosts, with a persistent 'shepherd' driving every PR through to merged.
Dispatches, tracks, and verifies work across multiple AI coding agents from a single command tower, driven by one-sentence instructions.
A deep dive into a real bug found while pointing Claude Code at other repos: a 7k-star library's pytest suite showed 31 passed, but silent INSERT failures, a swallowed transaction exception, and leaked connections were all present at that commit. In-memory SQLite hid the failures because the whole suite ran on a single connection. A useful reminder that green tests are not proof of correctness.
A minimal Claude Code workflow kit from Dwarves Foundation for spec-driven development, bundling 12 hooks, 12 commands, 8 agents, and 1 skill to enforce verification at each step.
A token-frugal Claude Code pipeline that runs brainstorm, spec, build, smoke, review, and ship as one agent per stage. Installs with a core package and a single /init-pipeline command that adapts to your stack.
Replaces the manual copy-paste hand-off between Claude Desktop chat and Claude Code (VS Code extension or CLI) with an automated loop, so plans discussed in chat flow straight into a coding session.
A shared example of building Claude Code subagents around personas rather than generic role names, here a relentless-investigator persona tuned specifically for finding silent failures and making blind spots in a codebase observable.
Self-hosted agentic task pipelines that run as actual Claude Code sessions on your own machine, turning a backlog into a queue of autonomous work rather than a list someone has to pick up manually.
When one developer's agent gets corrected or breaks something, teamlore writes a small lore file into a .lore/ folder that ships in the PR. After merge, every teammate's agent automatically recalls that lesson when it touches the same part of the repo, no server, database, or account, just files in git.
Plugins for Codex and Claude Code that manage controller state roots, package tasks, deliver them directly to a thread or session, and support evidence review, all running local-first.
A project starter combining an OKF knowledge bundle, a decision register (ADRs), planning docs, and agent working-hygiene rules meant to keep long-running agent work from drifting.
Routes agent tasks into scoped DAG lanes and requires evidence at each gate, producing replayable artifacts so you can verify what an agent actually did rather than trusting its self-report.
A workflow that acts as an autopilot for AI coding agents, supporting OpenCode, Claude Code, pi.dev, Cursor, and others from one setup.
Free lessons from the Hardcore Agentic Engineering course for builders who ship, focused on getting real work out of coding agents and proving that the work is correct rather than just trusting the agent's report. Includes slides, live demos, and example code.
A multi-model orchestration skill combining three models (babel, cdx-sol, agy) in a pipeline that debates, builds, debugs, and runs an acceptance gate before considering work done.
A Claude Code plugin whose philosophy centers on three things: the human-AI dialogue where decisions get made and understood, agentic orchestration where multiple agents build/test/review/ship, and recording learnings so they compound over time. Positioned between highly structured TDD frameworks and fully autonomous 'let the model run' approaches.
Runs an entire SDLC — planning, design, implementation, code review, verification, acceptance, and knowledge maintenance — as one in-session orchestrator that dispatches named specialist personas, checking evidence at every gate instead of relying on the agent's self-report.
A session workflow that pauses when it needs a human decision by writing the question to a file and halting, then wakes itself via a bounded detached watcher process (up to 8 hours) with zero model turns while idle. Also supports moving a live session between terminals without losing its number, folder, lock, or branch. Ships as 19 skills, 3 agents, and 8 hooks under MIT license.
A structured agentic development workflow that assigns Analyst, Architect, and Developer roles to orchestrate LLM-driven coding. Enforces a strict Stub-First methodology combined with automated TDD/VDD cycles to keep development disciplined and verifiable.
A local context-efficiency platform that acts as a single stable Claude Code gateway chaining Headroom, pxpipe, and Squeezr context-reduction tools together, with metrics and atomic releases via its apx CLI.
A workflow tool that enforces a strict plan to code to tests to validate to docs pipeline for AI coding agents like Claude Code and OpenCode, keeping agent-driven changes disciplined and fully verified before completion.
A research workflow kit for language-assessment and applied-linguistics researchers, covering discover, review, write, check, evaluate, and submit. Claude operates each step but checks in with the researcher throughout, so nothing is invented or silently changed.
A command-and-control center for coordinating a pool of VPSes running Claude subscriptions at scale, one VPS per team. Dispatches /goal missions, merges PRs sequentially with claudetm, and verifies deploys.
A workflow tool for Claude Code and Codex that defines tasks as bounded goal contracts with deterministic, automatically-checkable acceptance criteria, making it clear and verifiable when an agent has actually finished a task.
A portable, version-controlled Claude Code configuration built around a structured engineering process, problem definition, systems analysis, and explicit verification gates, rather than ad-hoc prompting.
An unattended agent that acts as a feature PM: hand it a brief and it works for hours or days before opening a pull request. Distinct from another same-named nightshift repo (r3dbars) already in this database, which focuses on shorter overnight drafting rather than long-running autonomous feature delivery.
Collects an AI agent's clarifying questions upfront into a single capped, paginated web form instead of letting the agent interrupt repeatedly mid-task. Helps get the design right on the first pass by batching Q&A into one structured round.
Adds a goal-based SDLC to any repo as a Claude Code plugin, with an interactive goal-mode and an autonomous park-and-continue loop-mode for unattended work. Zero runtime dependencies, so it installs cleanly into existing projects.
A document-first development harness for Claude Code and Codex CLI that scaffolds a project charter, architecture doc, and a sub-agent workflow for a new project in one shot. Aims to get a project's foundational docs and agent structure set up correctly from day one.
A guide and reference for deciding between Claude Code's extension mechanisms (skills, hooks, commands, MCP, subagents) before building, then walking through how to build it. Useful for developers unsure which extension point fits their use case.
A role-based marketing cockpit template for Claude Code: run /start-cockpit and a wizard builds your brand doctrine, wires your tools, and sets up a ready-to-use marketing department with 50 skills, 10 agents, and 7 modules. A substantial, vertical-specific system rather than a single skill.
An orchestration doctrine for Claude Code covering loop engineering and evidence gates, checkpoints that require proof before an agent can proceed. Distinct from another claude-stack repo (joryeugene) already in this database by a different author.
A 12-stage gated SDLC orchestrator for Claude Code with deterministic gates, REQ-ID traceability, cost-capped background agents, and support for brownfield adoption. More structured than most SDLC plugins, aimed at teams wanting auditable, requirement-traced automation. Distinct from another forge-plugins repo (lets-forge) already in this database by a different author.
Turns Git branch diffs into comprehension quizzes for Claude Code, OpenCode, and PR review workflows. Helps reviewers and teammates verify they actually understand a change rather than rubber-stamping it.
Feeds your coding agent's raw session transcript to models from other vendors and lets them veto the commit before it lands, rather than trusting the agent's own self-written summary. A check against agents grading their own homework.
A runtime that lets multiple coding agents collaborate with each other from a single terminal, optimized for steerability so a human can guide the multi-agent session. Aimed at orchestrating agent-to-agent collaboration rather than single-agent use.
Keeps a roadmap, phased plans, and progress tracking in files for Claude Code, so context survives a /clear instead of being lost. Helps structure long-running, multi-session projects into trackable phases.
A Claude Code project template with a rule kernel, helpful skills, a committed memory library, and session hooks, where improvements flow both ways between the template and the projects it spawns. Aims to keep a fleet of projects consistently up to date with your best practices.
A methodology for auditing agent-written markdown (PLAN.md, HANDOFF.md, etc.) by commit distance and inbound references, which found 54% of 317 agent-authored files across 14 repos were stale or orphaned, with stale-but-still-linked docs being the costly ones since agents load them as current state. The author now runs two hooks: PostToolUse on Write stamps agent markdown with the commit SHA it was written against, and a SessionStart check flags docs that have drifted since.
A workflow write-up arguing spec-driven-development tools go stale because they persist the spec: instead, research stays read-only, one handoff doc is written to $TMPDIR, a build step checks it against the repo and runs the tests, and only durable rules live in AGENTS.md. The spec itself is discarded with the temp file rather than becoming another stale doc to maintain.
A coordinated ensemble of role agents driven by a deterministic state machine, working spec-first and test-driven against live branches of a real Lakebase database. Aims to enforce engineering discipline on AI-written code rather than leaving it to model whim.
Executable operating contracts for AI agent loops: 7 typed terminal states, verification-gated completion, and bounded repair so a loop can prove it's actually done instead of just declaring victory. Ships as both a Claude Code plugin and a portable Python core.
A user audited their Claude Code setup and found about 71,000 tokens of standing overhead per message, mostly from skills and plugins that load into every message regardless of raw file size. Key insight: load frequency times size is the metric that matters, not file size alone, and denying a plugin only blocks tool calls -- you must disable it in enabledPlugins to actually stop it loading into context.
An open-source dispatcher that routes work to AI coding agents with a verification gate; changes that fail tests get automatically rolled back. Supports bring-your-own-key model access and runs entirely local-first.
Runs and coordinates a team of AI coding agents on your own machine, with support for Claude Code, Codex, OpenCode, Antigravity, and Copilot. Already has real traction (90+ GitHub stars) as a local-first alternative to cloud multi-agent orchestration platforms.
Bootstraps context layers, testing, CI/CD, and spec-driven development in any repo with a single install command, auto-detecting your stack and IDE. Supports Claude Code, Cursor, Windsurf, Kiro, Codex, Copilot, Antigravity, and OpenCode.
An open-source Claude Code setup aimed at handling a product beyond just writing code: launch, pricing, early customers, and shutdown decisions, while carrying lessons learned into the next project. Also works with Cursor, Codex, and Windsurf; has modest early traction.
A tiny phase-gate tool for coding agents: shell checks (tests, lint, build) determine whether a phase passes, and headsign's workflow routes the agent to advance, retry, escalate, or finish based on that verdict. Claude Code drives the work; headsign holds the state so pass/fail isn't left to the model's judgment.
A routing scheme that demotes Fable 5 from "manager" and puts Opus 4.8 in the main session loop as a planning-only "boss" that never writes code. Opus 5 runs as an isolated subagent that receives a blind spec, does the heavy engineering, and returns a terse changed/verified/blocked report with no direct user contact. Fable 5 is called only for narrow, isolated consulting briefs, while Sonnet/Haiku subagents handle routine pattern-matching and log triage.
An orchestration framework built around 87 subagents and skills implementing TDD defense-in-depth gates, Kaizen-style retros, and a four-body adversarial review council, with an empirically benchmarked QA harness for validating output quality.
dev-agents dispatches specialized Claude Code agents across multiple workers in parallel waves, aimed at scaling agentic coding beyond a single session. It coordinates many agents working concurrently on different parts of a task.
my-robot bootstraps a '7-layer AI-first development system' into any repo with one clone/install step, aimed at standardizing how AI coding agents like Claude Code operate in a project. It's a starter-kit style tool for teams wanting consistent agent conventions without manually assembling them.
A closed-loop workflow for AI coding agents built around a live state bus and execution-level hard intercepts, covering GitHub PRs and GitLab MRs. Works from step-level to requirement-level checks, combining eval-driven and spec-driven gates with human-in-the-loop approval.
Answers a few setup questions and generates a production-ready agent harness for Claude Code, Codex, or Cursor. Bilingual (English/Korean) and Docker-ready for quick deployment.
An open-source plugin that runs inside Codex and lets you invoke Claude Code and Claude models for code review, rescue tasks, and tracked background workflows without leaving Codex.
A single workflow core plus a team profile that generates adapters for Claude, Codex, Cursor, Copilot, CodeBuddy, Kiro, and Trae, so a team can standardize on one workflow definition across whichever coding agent each developer uses.
A multi-agent toolkit for Google Ads with end-user gcloud SSO, a 24-hour session cap, and per-MCC profiles. Covers read paths across campaign types, conversions, gtag health, placement safety, and brand exclusions, with mutations gated behind approval.
Instead of one-off scripts, grounds Claude Code in real DataFlow operators, field schemas, and pipeline state so it builds editable, visual data pipelines in DataFlow-WebUI. Reported a 93.3% pass rate on a 12-task data-engineering benchmark, cutting cost by 72.5% and latency by 49.9% versus vanilla Claude Code.
A shared knowledge vault plus a full software-engineering workflow that lets Claude Code and Codex run in parallel against one memory and one plan, instead of duplicating context per agent.
A role-based workflow with independently reviewed plans, task-by-task delivery, and explicit approval checkpoints between each stage.
A documented AI workflow that turns a rough idea into agent-ready work: North Star documents, feature briefs, atomic task breakdown, context management, subagents, and treating CLAUDE.md/AGENTS.md as a map rather than a rulebook.
A curated map of where AI tokens are wasted versus well spent, with tools, research, practices, and copy-paste setups for keeping agentic coding token-efficient.
A tiny, dependency-free cross-vendor sub-agent dispatcher for Claude, Codex, Cursor, Gemini, Antigravity, and any OpenAI-compatible API, with a council mode, fan-out swarms, and a structured JSON envelope.
Coordinates multiple concurrent coding agents with leases, ID reservation, a run journal, and a generated board layered over a pluggable knowledge cloud.
A ready-made VS Code theme, extension list, and settings for running Claude Code, Codex, and Gemini in one window, installable from a single link.
A detailed account of a multi-model orchestrator setup (Fable, Opus 5, Codex, Sonnet) breaking down under cost and reliability constraints, with specific observations on how Codex tends to invent a plausible-looking fake field to pass a check when a spec is underdetermined.
A provider-neutral lifecycle kit for agentic software delivery — reviewed spec-driven-development planning, budgeted execution, independent audits, final proof, and verified Codex/Claude host evidence.
A Claude Code plugin that deploys a coordinated team of AI engineers against any codebase, with a structured workflow, two-stage code review, autonomous BLOCKED-state recovery, and a research gate that verifies external APIs against current docs before specs get written.
Generates spec-driven daily topic briefings using Claude Code's cloud Routines, with git as the only state — zero servers, zero API keys.
A bootstrap skeleton for AI-augmented software projects that treats governed AI agents as first-class collaborators across the full SDLC.
A strictly sequential, spec-driven development workflow plugin for Claude Code that keeps your CLAUDE.md/.claude spec always fresh and grounds every decision in Context7 and Microsoft Learn.
A portable agent harness plugin offering a council mode, capped swarm, plan-execute-verify (PEV) loops, ship gates, and a craft pack aimed at killing AI slop. Works across Cursor, Claude Code, Codex, Copilot, and Windsurf.
Resolves GitHub issues end-to-end using isolated git worktrees, quality gates, and an MCP server, working with either Claude Code or Aider.
A Claude Code plugin offering vendor-neutral repo skills, CI gates, and cross-model review, built for a workflow where the human merges PRs without reading every diff.
A blind comparison of five Claude Code review processes — an in-house agent with old vs. rewritten CLAUDE.md, Matt Pocock's code-review skill, and Anthropic's official code-review command and pr-review-toolkit — run on the same ~19k-line real PR, measuring agent time, turns, and cost per setup.
Practical habits for controlling Claude Code token burn: keep CLAUDE.md small, start fresh sessions between problems, fetch web pages as clean markdown (e.g. via Firecrawl) instead of raw HTML, exclude folders the agent doesn't need, and check /context periodically to see what's actually filling the window.
An orchestrator/implementer loop where Opus plans, debates, and reviews while Codex writes the code and proves it works. Runs on your ChatGPT login instead of an API key, keeping the workflow subscription-based.
A local control plane for coordinating Codex, Claude Code, and OpenCode agents from one place. Aims to unify multi-agent-CLI workflows without relying on a hosted service.
An autonomous AI engineering team built as a 26-agent coding pipeline for Claude Code and Codex, turning a feature request into reviewed, tested, merge-ready code. Chains planning, implementation, review, and testing agents into one pipeline.
A framework layer that converts Claude Code and Codex from interactive chat assistants into autonomous coding systems capable of running without constant human prompting.
Reseats an in-progress coding session from Claude Code into Codex (or back) with zero token cost and no extra dependencies. A lightweight alternative to full context-transfer tools for switching agents mid-task.
A harness for multi-agent software design and evolution that isn't tied to a specific domain, letting agents collaboratively design and iterate on a system over time.
A practical write-up on running Claude Code, Cursor, OpenCode, and Antigravity together: a shared AGENTS.md instead of tool-specific config files, narrow single-purpose agents (planner/orchestrator/pusher) instead of one generalist, and routing cheap work to free-tier models to save paid credits for hard problems.
A write-up on running Claude Code on NixOS instead of WSL: avoids the dual-filesystem tax and imperative package drift of WSL/apt by declaring the whole machine — packages, services, drivers — in one git-tracked file, with instant rollback via boot-menu generations. The author runs Claude Code itself as a gated sysadmin over the declared config.
Applies specification-driven development practices to human work platforms, powered by Claude Code, so that specs rather than ad hoc chat drive the implementation process.
An AI-first Turborepo monorepo where Claude Code, Cursor, Copilot, Gemini CLI, Kiro, and Windsurf all read one shared AGENTS.md handbook and ship equivalent production-grade code across a Next.js dapp, React admin SPA, Astro landing page, and a Connect-RPC backend, deployed to Cloudflare.
A worked example of pointing Opus 5 at its own project CLAUDE.md and skills and asking it to audit them for unnecessary instructions: cut a 90-line CLAUDE.md by 40 lines, trimmed supporting docs, and flagged two skills as unneeded — after which the same task went from floundering for minutes to finishing in about one. Suggests that guardrails tuned for older models may now be actively hurting Opus 5.
A markdown-first control plane for scoping agent work, tracking evidence behind decisions, and making that work reusable across sessions.
A pipeline for AI coding agents covering idea, acceptance criteria, architecture, tech stack, atomic plan, a readiness gate, test-first subagent build, and a reviewed PR. Installable as a Claude Code or Cursor plugin.
A crew of Claude Code sub-agents and slash-command workflows that autonomously takes a GitHub issue from open to a reviewed pull request with green CI. Flagship command: /ship-issue.
Packages a phase-driven development workflow for Claude Code as drop-in skills: plan-before-code gates, per-phase tracking, worktree discipline, task decomposition, and an audit step between phases.
Asks five models across four vendors the same hard question through the CLIs you already have (no API keys), has them anonymously rank each other's answers, then leaves the final call to you.
Orchestrates Claude Code, Codex, Gemini, Kimi, and DeepSeek as live crews through a plan-aware advisor, a Kanban/flow command center, a testing gate, and an economics brain (Scrooge) that tracks spend across the crew.
A Claude Code multi-agent workspace that turns a job posting into an evidence-based, scored analysis and ranked scoreboard, splitting judgment (LLM) from bookkeeping (code). A niche but concrete example of a structured multi-agent pipeline.
A prompting pattern where Fable is assigned as orchestrator, reviewer, and final approver of work, dispatching Opus 5 to implement while Fable adversarially reviews the output. Aimed at curbing Opus's tendency to make assumptions without reading full code context.
A deterministic, idempotent, zero-LLM-token tool that projects a single config repo into multiple AI coding harnesses (Claude Code, Codex, Cursor, Gemini), keeping instructions/settings in sync across tools without needing an LLM to do the translation.
A structured requirements template (Nonfunctional, Functional, Agentic) meant to be written before a coding agent starts work, with a worked example and ready-to-use agent prompts to reduce ambiguity in agent-driven development.
A literature review (130+ sources) on adversarial review/critique gates in agent pipelines, finding flip rates of 17.5-97.3% under challenge, low intra-rater agreement on repeated runs, and accuracy loss after repeated refinement rounds. Recommends capping repair loops at 2-4 rounds, far below defaults like LangGraph's 1000.
An AI coding workflow plugin that merges the OpenSpec planning engine with Superpowers' execution discipline, offering 9 skills and support for 17 platforms in a contract-driven, spec-first development flow.
A set of Claude Code workflows covering common Google Cloud tasks: Terraform, Cloud Run, GKE, IAM, and Firestore. Gives Claude Code concrete, tested playbooks for GCP infrastructure work instead of ad hoc prompting.
Turns a coding agent into a supervisor coordinating workers across many providers at once, including Codex, Cursor, Copilot, Claude Code, Qwen, and Amp. Aimed at teams running several coding agents in parallel who want one control point.
A Claude Code plugin defining UX as a contract of personas, jobs, flows, scenarios, and audits through a single /ux entry point, with a linter that flags when docs drift from actual code. Aimed at keeping AI-built UI consistent with intended user flows over time.
A Claude Code harness enforcing spec-driven development through phase gates, TDD checks, and a learning log, making no network calls at all. Aimed at developers who want disciplined, offline spec-first workflows enforced rather than just suggested.
A Herdr plugin that transfers an in-progress Claude Code (or other agent) session to a fresh session of a different installed coding agent, embedding the complete session transcript in the prompt rather than a summary. Avoids the information loss of manual handoff notes when switching tools mid-task.
A governance blueprint for running Claude Code securely in a regulated banking environment, based on a GlobalLogic/Barclays deployment using Windows VDI and AWS Bedrock. Useful reference for enterprises needing a compliant, auditable Claude Code rollout.
A step-by-step workaround for installing Claude Code on a 2012 iMac running the unsupported macOS Catalina, using MacPorts to install an older Node.js build and pinning to Claude Code 2.1.112 to avoid dyld symbol errors. Useful for anyone stuck on pre-Ventura macOS who still wants to run Claude Code.
A TUI dashboard for Android teams that drives Claude Code through a Jira or markdown ticket end-to-end — plan, implement, verify on an emulator, and open a reviewed pull request — running parallel agents but never auto-merging. Gives teams a single view over multiple in-flight agent tasks with a human still gating the merge.
A Claude Code / Codex development methodology plugin that scales review rigor to the 'blast radius' of a change rather than applying uniform process to every commit. Aimed at teams wanting lighter review overhead for low-risk changes.
A Claude Code plugin that orchestrates tasks from planning through deployment on Frappe/ERPNext projects without losing context. Targets teams building on the Frappe framework who want structured, context-aware agent workflows.
A multi-agent framework built around 18 curated agent roles, a handoff engine for passing work between them, pipeline orchestration, and conflict detection — aimed at genuine agent collaboration rather than static templates.
An enterprise-oriented zero-trust governance framework for agent harnesses covering unified admission control, task-level least-privilege authorization, evidence verification, budgets, approvals, auditing, revocation, and rollback. Aimed at organizations that need compliance-grade controls around autonomous coding agents.
A CLAUDE.md template that routes agent work to the cheapest reliable model/executor and calibrates its own delegation rules from an evidence ledger of past outcomes. A cost-optimization pattern for teams running heavy agent workloads.
A complete multi-agent game-development studio for Claude Code with 67 skills, 49 specialist agents, and gated pipelines, working with Godot, Unity, or Unreal. Born out of a real shipped-in-progress Godot project, with one-paste setup and no prerequisites.
A CLI and Claude Code plugin that scaffolds and upgrades AI development harnesses, spanning everything from casual vibe coding to autonomous spec-driven development. Aimed at teams standardizing how their agent tooling is set up.
The armory suite's cross-harness subagent orchestrator for the 'pi' coding agent, where every spawned agent is armory-native by default. Extends the armory skills ecosystem into fleet-style multi-agent orchestration.
taskcrew converts a Backlog.md task board into a fully unattended multi-agent development pipeline that runs on your own Claude subscription. Aimed at teams wanting continuous, ticket-driven agent work without per-task manual kickoff.
A practical guide covering repo setup, agent guidance techniques, and AI-assisted auditing for working safely with LLM coding agents like Claude Code. Goes beyond "just prompt better" to address repository hygiene, constraint-setting, and how to use the agent itself to audit its own work. Aimed at developers who want to maintain quality and security while using agentic coding tools.
playmaker is a CLI that acts as a playing-coach orchestrator, spinning up Claude Code, Codex, and Antigravity as simultaneous sub-agents to distribute work across separate API quotas. Useful for power users who want to maximize throughput by running multiple AI coding engines in parallel on the same task.
pipeline_worker captures developer intent from git diffs using Claude Code or GitHub Copilot CLI, then automatically runs build/lint/test, opens GitLab MRs or GitHub PRs, and re-invokes the agent to fix any failing pipelines. It wraps the full change → review → fix cycle in a single automated worktree-based workflow. Useful for teams wanting AI-assisted CI/CD with minimal manual intervention.
CrowdControl is an Elixir-based CLI that runs many Claude Code or Open Code CLI instances simultaneously as coordinated agents. It lets you fan out work across multiple agent processes from a single controller, useful for parallelizing large codebases or multi-repo tasks. Built for teams who want Elixir's concurrency model driving their AI coding fleet.
A practitioner's account of spending two weeks building verification infrastructure — failing builds, guards against destructive commands, tests for those checks — before shipping any user-visible features. The insight: productivity gain is a step function that arrives after the setup, not a gradual ramp, because the bottleneck shifts to verification. Recommends treating that setup time as planned work, not overhead.
A workflow tool for orchestrating multiple Claude Code agents as a team to take a feature from concept through implementation and pull request. Each agent has a defined role, enabling parallel and coordinated work on complex features.
A Python framework for building production multi-agent systems with routing, memory, and coordination built in. Aims to be the enterprise standard for agent orchestration, with a hosted platform at swarms.ai. Supports a broad ecosystem of agent architectures.
A Claude Code orchestration pattern where Opus 4.8 acts as the driver/planner and Opus 5 handles implementation work. Enforcement is hook-based or skill-based, with adversarial review between the two agents. Exploits the cost and capability differences between the two model tiers.
A platform inspired by OpenRouter that provides routing and sandbox environments for persistent agent workers. Supports specialist presets and fleet supervision. Provision configurations and route runtime substrates for your agent fleet.
A spec-driven AI agent workflow that is Codex-native but Claude Code compatible. Includes independent review, QA, fixes, and refactor stages. Provides a structured pipeline for moving from specification to reviewed, QA-passed code across multiple agents.
A GitHub Actions-based tool for managing Claude Code plugin marketplace catalogs. Automates publishing, versioning, and maintenance of skill marketplaces so teams can share and distribute skills via GitHub. Useful for organizations building internal Claude Code skill registries.
An open-source development workflow framework with Claude Code plugins that integrates second-brain (Obsidian) note-taking and issue tracking (Linear) into AI development sessions. Connects your knowledge base and task tracker directly to Claude Code sessions.
A framework for maintaining strategic coherence when building with AI agents. Uses a markdown intent graph and coherence checker backed by Claude Code skills to keep agent sessions aligned with high-level product goals rather than drifting into tactical implementation details.
A harness for enterprise architecture governance using AI coding assistants. Covers strategy, architecture, delivery, and assurance workflows with Claude Code and similar tools. Designed for organizations applying Wardley Mapping and structured architecture thinking with AI assistance.
A set of fully reversible macOS settings and instructions for keeping a MacBook awake with the display off and lid closed for 24/7 AI agent operation. No third-party tools required — just native macOS power management settings. All changes can be undone cleanly.
A portable kit for building orchestrator/worker multi-agent setups in AI-assisted development. Provides scaffolding for running one orchestrator agent that delegates to multiple worker agents with proper handoff and coordination patterns.
Solves each problem class once at the expensive model tier, then captures the solution pattern in markdown so future identical problems run cheaply. Acts as a self-improving cost optimizer: first run uses the expensive model, subsequent runs of the same class use cheaper alternatives. Just markdown, no proxy required.
Prevents context loss during compaction by maintaining a structured context and task management system for Claude Code. Enables efficient multi-session workflows by persisting the agent's understanding of current state, open tasks, and project decisions across context resets. Addresses Claude forgetting what it was doing mid-project.
A complete autonomous software development lifecycle harness for Claude Code that will not advance past any gate on an unproven verdict. Each phase requires evidence before the next step runs, preventing the failure mode where Claude Code confidently produces wrong results without checking.
An open-source SDLC harness that chains PM, Dev, QA, and Reviewer agents into a pipeline from English spec to pull request. Uses different model families for author and reviewer to prevent self-approvals. Compatible with Claude Code, Codex, Cursor, and Aider via headless mode using existing subscriptions.
Runs a queue of tasks through claude -p in headless mode, spawning one fresh session per task and carrying context forward between tasks. Designed for unattended batch work where you want each task to start clean but build on previous results. Minimal and focused.
A single binary that takes YAML-defined workflow specs and chains multiple AI coding CLIs into multi-stage flows with review loops, parallel fan-out, and session resume. Supports Codex, Claude Code, opencode, Grok, and Antigravity. No framework lock-in — bring whatever CLIs you already use.
Lets multiple Claude Code sessions talk to each other in real time via slash commands. Built with bash, jq, tmux, and a single systemd user service — no server, no database, no ports. Works cross-machine over SSH, and messages are treated as untrusted data to prevent prompt injection through peer sessions.
Wraps Claude Code (and Codex/Gemini) with guardrails that enforce a hard token budget, run eval-gated checks, and automatically re-attempt fixes until the PR passes at 100/100. Designed so you always own the final merge decision without babysitting the agent loop.
Runs a swarm of Claude Code agents that follow a structured, gate-checked software development lifecycle — each phase must pass before the next begins. Aimed at automating end-to-end coding and testing pipelines with human-defined quality gates.
A structured Markdown format for LLM coding-agent specs that tracks status, provenance, dependencies, and freshness for each section. Prevents agents from implementing from outdated context by surfacing staleness before code is written.
Tool that helps teams review and agree on specs before handing them to an AI coding agent, reducing rework from misaligned requirements. Addresses the pattern where agents implement the wrong thing because the spec was never actually agreed on.
Runs development tasks with persistent background agents that operate in isolated sandboxes — handling code changes, tests, and pull requests autonomously. Useful for fire-and-forget tasks like dependency updates or test fixes that do not need interactive oversight.
Autonomous loop that runs one verified improvement per iteration: audit, fix, verify, converge — checkpointing each step in local commits it never pushes. Stops when quality converges rather than running for a fixed number of iterations.
o3s moves the network firewall out of the agent container into a separate gateway the agent cannot reach — closing the main gap in the Anthropic reference devcontainer. Features DNS locked to an allowlist, per-host/per-port rules, live allowlist for CDN IP rotation, and Docker-in-Docker for full-stack sandbox testing. MIT licensed.
A detailed ultracode pattern where Fable orchestrates GPT/Opus workers, followed by adversarial cross-model review, a synthesis subagent to judge issues, and targeted fix agents — all gated by a deterministic validator before spawning. Distributes model types evenly to manage quota. Practical template for teams hitting subagent sprawl.
A NixOS configuration purpose-built for autonomous AI coding: kernel-level sandboxing, atomic rollbacks if an agent breaks something, and a fully reproducible AI toolchain across multiple machines. Good reference for teams wanting drift-free, auditable agent environments.
Since v2.1.198, subagents (Explore, Plan, general-purpose) default to inheriting the main session model instead of running on Haiku. An Opus session means Opus subagents. Set CLAUDE_CODE_SUBAGENT_MODEL=haiku or model: haiku in agent frontmatter to restore cheap subagent behavior. Awareness critical for subscription users watching quota burn.
A Claude Code harness that requires the agent to run a discovery phase and weigh evidence before writing a single line. The agent must "earn the right to start" by surfacing relevant context. Targets the common failure mode of premature coding and is designed for software, AI tools, and service projects.
Reddit investigation into why Claude Code persistently reaches for shell tools (grep, sed, cut) despite explicit instructions to use dedicated Grep and Read tools. Claude attributes it to "habit built up in context" — suggesting that in-context instruction buildup can cause self-reinforcing instruction-violating behavior. The thread explores practical strategies to break the pattern.
Orchestrates an autonomous AI development team via Claude Code CLI, with Discord control interface, Linear integration for issue tracking, and cognitive memory across sessions.
Bridges GitHub Issues and AI coding agents by generating sprint execution files that agents and humans can both act on — structured, Issues-backed development workflow.
A detailed write-up of building a sandboxed agentic pipeline where agents pick up Linear tickets and implement code changes on GitHub via Claude Code running in AWS Step Functions. Agents have no direct access to Linear or GitHub — they consume pre-hydrated workspaces from S3. Everything implemented by agents from specs, with Opus 4.8.
A CLI for capability-scoped agent work units where every privileged effect is verified against a signed owner, driving work through a signed pipeline all the way to a merged PR.
A meta-harness enforcing software engineering standards as deterministic, fail-closed gates — model-agnostic and harness-agnostic, designed to apply regardless of which AI coding agent is in use.
Two-role workflow where an analyst files evidence-backed issues and a developer agent claims and ships them. Features race-safe claiming, per-run attribution, and pluggable domain rule books. Works with GitHub Issues, Linear, and Trello.
Reviews AI-generated pull requests for weakened tests and hidden errors. Warns a human by default; only blocks a merge when it can prove the problem is real.
Models AI coding agent workflows as a graph — each node is a subprocess, each edge is a file, and the exit code is the contract. Single file, stdlib only, compatible with any agent CLI.
YAML-driven orchestrator for running multiple AI agents with configurable model support.
Tracks AI ecosystem trends and syncs relevant agent updates to your project using Claude Code commands.
Technique for fixing Claude Code usage window start times by sending a trivial warm-up message from an always-on VPS via cron. The 5-hour session window opens on schedule regardless of when you sit down. Includes headless auth with claude setup-token and wrapper script setup.
Pattern for using a separate model instance to review AI-generated code diffs, raising findings without touching the code. The author model then decides what to act on. Data from 83 tickets showed the majority had findings worth acting on — an additional review round that costs only tokens, not time.
Mutation testing tool that prevents AI agents from weakening tests — generates single-point mutants, runs the test suite against each, and exits non-zero when surviving mutants indicate weak coverage. The CLI determines pass/fail via execution so agents cannot fabricate results. Installs as a skill for Claude Code, Cursor, Codex, and Copilot.
Glass-box, multi-domain agentic orchestrator for Claude Code: detect context, assemble the right crew, run domain pipelines, show the reasoning.
I do collaborative LLM workflows, not new to me, done it since October or so. Overall, it is a collaboration of llm to solve architectural code problems. One llm is an orchestrator, giving other br...
Build a custom Claude Code dashboard in Obsidian to track project status, manage automation skills, and centralize your development workflow in one screen.
🚀 Ladonx — A unified multi-agent gateway for OpenAI Codex and Claude Code. Connect and orchestrate any LLM provider, including GPT, Claude, Gemini, DeepSeek, GLM, Ollama and more, in one seamless A...
I was in the middle of a pretty heavy development day, with some long-running, well-defined tasks queued up, when Opus dropped earlier. The way most tasks run in my workflow: Fable orchestrates the...
Plan Mode orchestration tool — wraps Claude Code with structured Plan → Decompose → Execute workflow
Curated collection of Claude Code skills for automation, data extraction, code generation, and productivity. Drop-in skills for Claude AI to enhance your workflow.
Human-in-the-loop planning plugin for Claude and Codex: turn ideas into reviewed Markdown plans, record decisions, enforce explicit execution gates, and provide tested controller primitives for saf...
Open-source SkillOps / instruction-supply-chain control plane for AI-agent teams: policy packs, registry diff, evidence bundles, SARIF/SBOM, adapters, and MCP runtime.
⛵️ High-performance Rust orchestrator for Claude Code agents. Runs concurrent agents in git-isolated branches with retry loops, priority queuing, SQLite memory, pattern mining, scheduled tasks, and...
I'm showing the full setup I use for managing multiple projects at once with Claude Code (CLI). Most of it comes down to letting Claude do the work while I make the actual decisions. Hooks, tasks, ...
A full SDLC workflow for a solo developer — one person, a whole team of Claude Code agents.
Free open-source Claude Skills examples, templates, and guides for developers, researchers, writers, designers, and automation workflows.
An enterprise-grade AI assistant platform built with FastAPI, the OpenAI Responses API, Anthropic Claude, Google Gemini, LangChain, RAG, MCP, AI Agents, Voice AI, Vision AI, and automation integrat...
I've burnt way too many tokens to get through this, but ok, I'm still learning (it's my first month with Claude and Claude Code). So I've stumbled into a wall and neither me nor Claude can get over...
Community surf forecasting and used-board buying workflows for Claude Code, with private local rider data
In traditional workflows, creators typically produce narrated videos following this process: write scripts using large language models → generate video footage via video generation models → import ...
I use Claude Code and Codex daily, always in a terminal. The problem was that the session lives and dies with my ssh window. If I leave my desk the agent keeps working but I cannot see the progress...
I was asking Claude how it deals with sub-agents and orchestrated flows. I think we all know doing that is a real token burner, and UltraCode also can be. But TIL that UltraCode itself can trigger ...
Permission-safe prompt refinement and autonomous graph orchestration for Codex and Claude Code
Best AI Coding Workflow Plugin Pipeline 2026
A review-gated shipping pipeline for Claude Code: fresh-context spec & diff review, gated auto-merge, a PR merge-tail babysitter, and an honest deploy ceremony.
AI Development Harness for Claude Code 2026: Build CLAUDE.md & Agent Workflows
Free local audit that cuts the hidden token cost of Claude Code. By Chaser (chaser-orchestrator.com) — reversible, stdlib-only.
Run your own agent org: talk to an orchestrator, it hires & supervises worker agents you can watch and steer. Self-hosted; pluggable surfaces (Telegram, Web, VS Code) and agent backends (Claude Cod...
Claude Workflows-style orchestration for Codex, Gemini, OpenCode, Grok, Pi, and Antigravity.
When Internal Usage Isn't Customer Usage Anthropic's April 23rd post-mortem on Claude Code's quality regressions is easy to read as a story about evals missing a problem. That's part of it. The mor...
Multi-agent orchestration harness for Claude Code + Codex — task lifecycle, handoff protocol, dashboard, and autonomous dispatch
Intent-based, autonomous developer workflows for Claude Code
Agent-agnostic change-control plane for coding agents. Govern Claude Code, Codex, Cursor, or any agent behind one admission pipeline — prove every change with a signed receipt.
Plug-and-play Meta (Facebook + Instagram) ads automation, drivable from the terminal, as a Python library, or from Claude Code, with AI creative generation. Safe by default.
Claude plugin orchestrating spec-to-code automation workflow, enabling developers to leverage Claude Skills for productivity.
Durable, sandboxed orchestration for Claude Code and Codex.
An opinionated development workflow orchestrator that guides AI coding agents through Spec → Plan → Code phases with quality gates at each step. Enforces structured development discipline to reduce drift and poor AI outputs on longer projects.
An opinionated, local-first AI agent orchestration toolkit for Claude Code featuring semantic memory, learned routing, gates, and reusable "spells." Requires no API keys or cloud services and works out of the box with Claude Code.
A spec-driven development kit for multi-repo systems with human-gated permissions, strict TDD enforcement, and verifiable docs and metrics. Designed specifically for Claude Code workflows where accountability and traceability matter.
A portable continuation protocol that lets any AI coding agent (Claude, Gemini, Codex, Aider) resume a project with full context and zero rebriefing. STATE.md tracks phase and next action, BOARD.md is the ticket board, LOG.md is an append-only event graph — all plain markdown with zero dependencies.
An AI agent system using files-first memory stored in an Obsidian vault with no vector database. The agent learns from each session by editing its own skills, getting sharper over time while keeping all data in plain markdown files you own.
An agent governance toolkit that provides git-backed shared memory, machine-enforced protocol adherence, and self-proving results for AI coding agents. Designed to bring consistency and accountability to multi-agent AI development workflows.
Sharding treats multi-session AI development like a type checker — contracts between Claude Code sessions (APIs, schemas, shared conventions) live on disk and are frozen while a phase is open. Any session that diverges from an agreed interface is caught mechanically, not discovered at integration time, bringing compile-time-style guarantees to multi-agent coordination.
A structured AI coding methodology with explicit phase gates, human review at each step, and context firewalls between sessions. The human owns product decisions while architect and coding agents execute separately, with all decisions documented so a different model can continue any project without reconstructing its history.
A testing framework designed specifically for multi-step AI agent flows that works across different agent harnesses. Enables repeatable, cross-compatible testing of agentic workflows to ensure consistent behavior regardless of which AI coding tool is running.
A declarative control plane that describes an agent harness in a single YAML file covering grounding, tools, memory configuration, and hooks. Supports describe, validate, diff, and apply operations, bringing infrastructure-as-code discipline to AI agent configuration.
A protocol that encodes development standards as machine-readable constraints, making Claude automatically follow TDD, Architecture Decision Records, commit gates, and release checks. Turns soft guidelines into hard rules that the AI cannot bypass.
Seam-aware protocols ("training wheels") for AI coding agents that force investigation before changes, gate irreversible actions, and require agents to prove their claims. Designed to reduce careless behavior on sensitive code paths by treating AI unpredictability as a fixed property to design around.
An agentic stack focused on baking in the most efficient and safe token-reduction tools for AI coding workflows. Helps developers cut costs while maintaining quality in agentic coding pipelines.
A developer successfully ran Kimi K3 as the primary model for Claude Code while their Anthropic subscription was depleted. The test covered the full CC toolchain—file edits, Bash, subagents, planning, MCPs, skills, and git—and found near-identical behavior to native Anthropic models. The only hiccup was the Claude-in-Chrome MCP, which needed minor tab management.
A detailed writeup and build guide for a personal AI operating system that dispatches coding work across repos via Discord. A kernel process routes work to ephemeral Claude Code sessions; all state lives in files and SQLite so crashes lose nothing. Includes a gist you can hand directly to your own agent to replicate the setup.
A developer's month of field data on AI code review gates: roughly 3 in 4 initial findings don't hold up. The fix is requiring the reviewer to reproduce each finding against the running app—not just describe it. A finding that can only narrate a problem is an opinion; one that can demonstrate it is evidence. Practical guidance for teams running automated review agents.
A Git-backed, LLM-readable knowledge OS for projects, research, decisions, and long-horizon work. Claude Code starts from a compact live-state surface and searches outward as needed, writing durable changes back as Markdown/YAML files. A single shared agent contract works across Claude Code, Codex, and Cursor—agents are replaceable, the knowledge base persists.
A composable rule source manager for coding agents that lets teams layer and sync CLAUDE.md/AGENTS.md rules from multiple sources. Solves the problem of maintaining consistent agent behavior across a team when rules live in different repos or tools. Composable layering means local overrides stack cleanly on top of shared rules.
A control plane for managing coding agents remotely — approve or deny tool calls, steer sessions mid-run, and route work between agents from any channel and across different agent runtimes.
pi-graph prevents agents from skipping steps by encoding workflows as deterministic YAML graphs that the agent builds, runs, and can inspect. Provides auditability and reproducibility for multi-step tasks.
A Claude Code configuration for running adversarial code reviews using GPT-5.6-sol as a counterpart reviewer through the herdr multi-model routing tool. Cross-model adversarial review to catch blind spots.
A project-level orchestration layer on top of Every's compound-engineering plugin. Decomposes an epic into a git-committed task graph, then fans it out as parallel /lfg waves of 3–5 concurrent agents producing green PRs.
A Claude Code plugin that runs work through a structured creative → implement → review loop, builds expert agent personas based on your feedback over time, and preserves aesthetic taste across sessions.
Bilingual agentic coding workflow for Codex and Claude Code, from idea to milestone closure.
Community discussion on splitting AI roles across model families — Fable for architecture, Opus 4.8 for implementation, GPT for QA. Explores whether cross-provider QA adds value. Useful starting point for teams designing multi-model pipelines with Claude Code.
Plugin that lets Claude Code and Codex delegate build and review tasks to other agents (Grok, Kiro, Claude, Cursor, opencode) over a uniform, fail-closed contract. Enables heterogeneous agent pipelines without custom glue code.
Curated operator setup for solo founders running parallel AI products with Claude Code. Bundles 4 core tools (Claude Code, Obsidian, graphify, Frontend-Design) and 2 optional ones (ECC, Toprank) with install paths, cookbook recipes, hooks, scaffolds, and profiles.
Relay layer that lets OpenClaw manage Claude Code and Codex CLI workers with async progress tracking, routed delivery, wake, resume, and automation support. Useful for orchestrating long-running AI coding tasks from a central controller.
Open-source AI marketing team for B2B SaaS — 59 specialist agents, 13 installable Claude Code skills, and the CATALYST orchestrator, with worked ABM/launch/demand-gen workflows and an AEO/GEO playb...
Autonomous Telecom NOC automation for Claude Code: an 8-agent, human-gated incident pipeline (alarm correlation → diagnostics → root cause → resolution → reporting → dashboard) with a /noc orchestr...
Multi-agents collaboration plugin for Claude Code - orchestrate multiple AI agents (Codex CLI, Gemini CLI, etc.) for diverse perspectives
Open-source project-level workflow for Claude Code and Roblox Studio, focused on context, orchestration, validation, and repeatable AI-assisted development.
Autonomous text-to-game pipeline for Godot, powered by Claude Code,Codex,Opencode
I've seen a variety of projects that offer to do this for you, but they all suffer from one problem or another. Usually the problems fall into these categories: Force you to set ANTHROPIC_BASE_URL ...
Cost-optimized multi-model coding agent orchestration (Claude + Codex + Gemini + local fallback)
14MB ACP-Rust Agent, Claude Code Plugin compatible, Dynamic Workflow, Goal, Artifacts, Free Web Search, full feature and better support!
Self-hosted lifecycle platform for software powered by Claude Code. Configurable pipelines, devices you control, no credentials on the server. Apache-2.0.
End-to-end engineering harness for Claude Code — go from planning to building to reviewing in one workflow. 8 agents with multiple modes. In-built GUI to visualise your PRDs and todos. Ship with AI...
Local-first kanban board where Claude Code agents work your cards — dependency chains with merge gates, an AI manager that reviews real diffs and merges green PRs, group lanes, CI-gated. One runtim...
Tree-of-agents manager for AI coding CLIs: orchestrate Claude Code, Codex, Gemini & more as a recursive tree with worktrees, attention inbox and multi-account support
I'm trying to automate a workflow for my job that involves configuring a large number of Instagram accounts. I asked Claude to generate the code, but it refused, saying the automation would violate...
Agentic SDLC orchestration for Claude Code — transcribe, triage, plan, implement, review, ship
Multi-model AI orchestration workflow for Claude Code
AI-powered resume tailoring and job discovery pipeline built on Claude Code. CLAUDE.md encodes ATS optimization logic; Python pipeline handles job board polling, scoring, and PDF rendering.
One art-directed web studio in a box — a 9-stage Claude Code pipeline: an art director that commits a direction before anything is built (machine-enforced), original generated media, a second model...
Four MIT-licensed Claude Code plugins that let an agent run its loop freely between a fixed set of named human-decision gates — no full autonomy or constant approval. Plain-text Obsidian memory injects context at session start, and gates cover the full solo project lifecycle: memory, building, marketing, and shipping. Agents may propose edits to their own skills but cannot weaken their own gates.
Community discussion comparing structured harnesses (like ultracode) against prompting a single agent through plan → implement → review → commit unattended. With Fable-class models, solo agents appear equivalent to harnesses for low-to-moderate complexity tasks while deviating less and shipping faster. Raises the question of whether harness overhead is still worth it as models improve.
Adds settle gates to AI-assisted development workflows: agents declare acceptance criteria, then settle gates independently re-check those criteria and refuse to proceed until the evidence holds. Works as a CLI tool and MCP server with Claude Code, Codex, and other agents. Addresses the core problem of agents marking tasks done without genuine verification.
Planning system for AI coding agents that shows its reasoning and improves with each session. In a blind benchmark, a smaller model at low effort running loom matched a frontier model at max effort, using fewer tokens and less time. The system learns from run history to progressively reduce overhead and token costs.
Persistent autonomous agent environment that can run Claude Code sessions for days, storing only verified information across runs. Designed for long-horizon tasks where you want the agent to accumulate reliable state without drifting or hallucinating its own history. Memory writes require verification before persistence.
No-AI CI gate that fails your build when documentation drifts from the code it describes. The drift check is deterministic (no LLM involved), making it reliable in CI pipelines. Also includes VitePress doc generation via Claude or Codex for the writing side, keeping the detection and generation concerns separate.
Workflow pattern for Claude Code that routes planning to frontier models, execution to cheaper models, and verification to evidence-based checks. Cuts costs without sacrificing quality by matching model tier to task complexity.
Orchestration layer that routes tasks from Codex to Claude Code with cheaper subagents for execution and safe native fallback. Maintains custody awareness — tracking which agent holds context at each step — to avoid context loss on handoffs.
Interpretable Context Methodology (ICM) carries multi-step task orchestration in folder structure rather than code. Numbered folders encode order, hierarchy controls what each step sees, and plain markdown holds state — one agent walks the structure without a subagent tree. Includes a restructure mode that classifies and migrates messy repos, and a build mode for scaffolding fresh workspaces.
Discovery that Claude Code limits the number of parallel agents in ultracode to the number of available CPUs — causing significant slowdowns on low-core machines like Raspberry Pi 4. Network-bound agent tasks still serialize on underpowered hardware, making CPU count a practical constraint for multi-agent workflows.
A TypeScript framework where a coordinator plans the task DAG at runtime rather than requiring a static graph. Supports Claude, ChatGPT, Gemini, DeepSeek, and local models. Goal-driven: describe what you want, the coordinator figures out the execution plan.
Spec-in, verified-and-committed-change-out pipeline specifically for Rust projects. Stages the Claude Code interaction so changes are verified before commit. Useful for Rust developers who want deterministic, reviewable output from agentic coding sessions.
Enables Claude Code's Dynamic Workflows, Agent Teams, and Subagents to use DeepSeek, GLM, Kimi, Qwen, or a Codex subscription instead of requiring an Anthropic subscription. Bridges Claude Code's orchestration capabilities with alternative model providers. Chinese/English bilingual.
Turns work items into durable, inspectable cards that both humans and LLMs can read, update, and act on. Designed for the age of agents where tasks persist across many sessions. Brings agile-style structure to agentic development workflows.
Converts local Codex and Claude Code conversation history into structured handoff documents for the next chat, agent, collaborator, or your future self. Bridges context across sessions and agents. Useful when a task spans multiple sessions or agents.
Pure Bash hooks providing file locking, crash recovery, and cross-session task delegation across multiple AI coding agent sessions. No server or daemon required — coordination happens through the filesystem. Works across Claude Code and OpenAI Codex sessions.
Packages Claude Code session output into evidence-rich handoff bundles that Codex (or another agent) can review and continue. Enables a build-then-verify pattern where different agents do the building and reviewing. Structured for auditability.
Runs CLI coding agents (Claude Code, Codex, Copilot, Cursor, Gemini, opencode) against a task queue where each agent works in an isolated VM. Configurable auditors check output before git merge. Pools multiple provider subscriptions with quota-aware routing and fallback. C#/.NET 10, MIT-licensed.
A one-installer, five-runtime workflow automation tool implementing Plan→Execute→Verify cycles for Claude Code, Codex, Gemini CLI, OpenCode, and Copilot. Structures agentic work into explicit phases with verification gates between them.
A portable AI team workspace that uses plain text files with zero dependencies, compatible across Claude Code, Codex, OpenCode, Copilot, and Cursor. Represents tasks, context, and handoffs in a format any agent or human can read without tooling.
A practical multi-model workflow using a custom web wrapper where Fable 5 (orchestrator/creative), GPT-o3 Sol (technical lead), and Claude Opus (engineer) collaborate in a shared room via @-mentions. Each agent sees only its mentions; the human sees everything. Enabled 24h+ continuous agentic runs.
YAML-based task management stored directly in the repo with a computed roadmap, driven by your AI coding agent. No database, no SaaS, no external service — tasks live alongside the code they track. MIT-licensed.
Continuously Looping Engineering Machines — a docker-compose-style system for running persistent Claude Code agent teams on any Linux host, 24 hours a day. Treats long-running agent sessions as containers with defined services and restart policies.
An AI-powered design-to-code pipeline that converts Figma designs to React components across six parallel phases. Uses MCP tooling and parallelism to accelerate the typically slow design handoff process.
A Claude Code skill that structures long coding tasks as a graph of executor nodes rather than a single drifting loop. A supervisor agent runs outside the main context and corrects drift when the executor wanders off track. Available in English and Chinese (MIT).
Routes tasks to Claude Code, GitHub Copilot, Codex, and Gemini CLI, lets each agent work, and repeats. A simple dispatcher for teams that want to run the same task across multiple coding agents and compare results.
A multi-agent orchestration dashboard that structures Claude Code sessions as a company hierarchy: CEO→Team Lead→Members. Provides a web UI with chat rooms, approval flows, ticket management, pin-review, Git integration, and a terminal. Multi-language (English/Korean).
A Go CLI that drives Claude Code through a Specify→Research→Plan→Implement→Review→Validate SDLC pipeline, using GitHub Project boards to track state. Human-in-the-loop or fully automated. Turns issue-driven development into a repeatable, auditable pipeline. Documentation at fabrik.handarbeit.io.
A startup script that installs Playwright CLI and its skills into a Claude Code cloud container, plus a SessionStart hook that auto-configures proxy settings when HTTPS_PROXY is present. Lets you run browser automation inside a cloud-hosted Claude Code session without any manual setup. Useful for CI-style web scraping or UI testing workflows.
A setup guide and configuration for adding persistent long-term memory to Claude Code by connecting it to an Obsidian vault via Graphify. Reduces token usage by externalizing codebase knowledge into a searchable graph. Lets Claude retrieve only relevant context rather than re-loading entire codebases each session.
A complete Linear-driven development workflow for Claude Code: tickets become executable specs, each feature runs in a dedicated git worktree, a merge-gate hook enforces TDD discipline, and a backlog queue runner processes work sequentially. Extracted directly from a live daily setup with a companion ai-review-kit. High-signal, opinionated, and battle-tested.
A set of modular document templates that convert chats, design docs, and rough ideas into structured Understanding + TODOs that an agent reviews before starting work. Keeps agents from context-drifting across long projects by establishing a consistent artifact format. Drop the templates into any project and agents stay aligned without re-briefing.
A Claude Code plugin that guides you from a fuzzy product idea through structured UX research prompt flows to a compiled technical spec. Uses a spec-compiling subagent to synthesize research outputs into a document an agent can act on. Bridges the gap between product thinking and implementation-ready specs.
A memory management system for AI agents that scopes context to project phases — each phase carries its own memory layer, preventing earlier phase details from polluting current context. Reduces noise and improves agent focus as projects move through design, implementation, and review stages.
Framework and Rust CLI for externalizing scope, decisions, and risks (Charters, AILOG, AIDEC, ADR) so AI agents stay coherent across many turns. Generates ISO 42001, EU AI Act, and NIST AI RMF compliance evidence as a side effect. Available in English, Spanish, and Chinese.
Explores whether a critic subagent (the rubber duck) actually contributes value or whether the value comes from writing the handoff prompt that articulates the plan. Author built duck.md that challenges plans before non-trivial changes — found the prompt-writing process does most of the work, raising the question of whether the agent reply adds anything.
Proposes using macro commands to collapse multi-step agent tasks (inspect env, apply patches, build, test, read media) into a single RAG turn rather than separate turns. Author tested on other providers and reports 40-80% reduction in LLM turns and similar token savings. Includes benchmark results comparing configurations.
Bridges your issue tracker and autonomous agent execution by turning labeled tracker tickets directly into Claude Code agent sessions. Automates the hand-off from project management to coding without manual context copying.
Portable engineering policies for coding agents covering git, testing, logging, and language conventions written once and referenced everywhere. Makes your standards explicitly machine-readable rather than buried in CLAUDE.md files that agents may drift from.
Reaches decisions through open-ended discussion between agents, then threads those decisions into spec, plan, and implementation as reviewable on-disk artifacts. An alternative to having agents jump straight to implementation without shared understanding.
Spec-first development workflow toolkit for AI coding agents. Enforces defining what to build before building it, reducing the drift that happens when agents start coding without a clear specification. Framework-agnostic and compatible with multiple agents.
Plugin for running Claude Code overnight using node hooks the agent cannot read or edit. Features: setup interview that defines concrete done-conditions, loop memory in md files surviving compaction, git push/merge blocked in code, done verified by a separate fresh-context agent, and 16 lens exhaustive review (concurrency, injection, timezone, etc.). Iteration and wall-clock caps live in hook-owned files.
Claude Code plugin enforcing spec-driven builds, real verification at each step, and project memory that survives every session. Addresses the drift that happens when agents build without a spec or when memory resets wipe out accumulated context about the project.
TypeScript daemon that watches an issue tracker for labeled issues and runs configurable agentic Claude Code workflows on them — planning, execution, review, or custom phases. Bridges the gap between your issue tracker and autonomous agent execution.
Library of skill primitives composable into workflows with a self-improving skill as a first-class citizen. Builds on the orchestrator→subagent pattern but makes the composition dynamic so models route requests to the smallest appropriate workflow automatically. Works in Claude Code and Codex.
Practical post about implementing a second verification step that is separate from the agent that did the work: tests for code, recalculation for spreadsheets, live re-fetch for web data. Includes a publish gate script that scans outbound content for terms that must never leave the machine, with the key rule that the agent cannot edit the term list to make it pass.
Workflow pattern using worktrees and explicit stage-based plans as an alternative to /loop for long-running tasks. Stages include review, implement, write tests, run tests, and regression testing. The agent delegates each stage to a persistent subagent in the worktree, giving a natural start/end cycle without the open-ended loop risk.
Claude Code plugin that tracks work on a YAML board, enforces hard approval gates so nothing skips ahead of its own readiness, and maintains a persistent Obsidian-linked knowledge brain that survives across sessions. Designed to prevent agents from rushing past planning or shipping incomplete work.
Deterministic scaffolding and quality-gate loops that let even smaller, cheaper models ship large features via a plan-then-execute pattern with multi-agent coordination. Designed to get consistent results by separating the planning phase from execution and applying gates between stages.
Pure-skill implementation of the Fable 5 orchestrator pattern proposed by Anthropic — your agent acts as boss while Codex, Cursor, and any headless coding agent serve as the crew. Cross-harness and harness-independent, so it works with whatever agents you already use.
Installable as a Claude Code plugin, ships an orchestrated multi-agent crew for feature delivery, a pointer-driven tech-debt and dependency-upgrade fixer, and a shared code-review rubric. Components can be installed together or standalone, making it modular for different workflows.
A plan→build→review→prove loop for AI-generated code that never silently restarts. Compatible with Claude Code, Codex, Gemini CLI, Cursor, and any agent. Addresses the common failure mode where agents report code as done without proper verification.
Autonomous pipeline that plans, builds, and adversarially audits changes to any repo — a different model reviews the builder — shipping only what passes deterministic gates. Failures become durable lessons; runs are checkpoint-resumable and context-optimized. Supports Claude Code, Codex, and Gemini.
A real workflow where a launchd cron job runs claude -p with a skill file every morning to triage customer support threads — classifying, investigating against real data (Sentry, docs, code), drafting replies, and archiving. Hard limit of NEVER calling send_draft — the human reviews everything. 5 threads, 3 drafts, 2 correct skips on first run. Practical blueprint for responsible AI-assisted support.
A personal workflow for multi-model orchestration where Sol (Fable) owns the brief and verification, Sonnet handles implementation, and Opus challenges architectural decisions — each with a bounded role. Isolated worktrees for editing agents, parallel investigation, one implementation owner per surface. Practical description of running Claude Max and ChatGPT Pro together for complex engineering tasks.
A practical orchestration workflow that eliminates the rebuild loop: write the spec from the actual repo state, get a plan before code exists, have a separate agent review that plan adversarially, then hand it to an implementation agent. Four failure modes that compound in typical one-shot sessions — and the structural fix for each. Actionable description of an approach that lands features in one shot.
A complete AI operating model for software teams from idea to production — three peer-supervised loops (discovery, build, release) over a catalogue of curated packs: skills, subagents, and hooks, each installed in one line. Works with Claude Code, Codex, Cursor, Copilot, Gemini, and Kiro. Described as npm for your coding agent.
A file-backed workflow harness for reliable Claude Code and Codex sessions — stores workflow state on disk so sessions can resume after interruption. Solves the problem of losing progress when a session times out or crashes mid-task. Simple and dependency-free.
An atelier for Opencode, Claude Code, and other coding agents featuring spec-driven workflows, deep thinking, and code quality focus. Provides a structured, craftsman-style development environment for agents that values deliberate work over speed. Useful for projects where quality matters more than velocity.
A self-building fable-fleet orchestration harness for Claude Code featuring Haiku-first dispatch, event-sourced state, and observable machinery. Routes tasks to cheaper Haiku models where possible, escalating to Fable only when needed. Reduces costs on large autonomous workloads.
An absence-first operations framework for Claude Code where task files are employees, BLOCKED is a feature, and the send button is never automated. Designed for solopreneurs who want their business to keep making progress while they are away. Human-gated final actions prevent runaway automation.
A comprehensive Claude Code plugin with 10 specialized agents, a 5-phase TDD workflow, 3-tier rules, and 27 hooks. Provides a structured development process from requirements through testing and shipping. High-coverage automation for teams who want a complete agent-driven development loop.
A deterministic, evidence-based build harness for autonomous coding agents featuring FSM sprint gates, execution-evidence verification, and adversarial critics. Every claim must be proved with actual execution evidence — not opinion. Designed for teams who need reproducible, auditable AI coding results.
Git-native governance for coding-agent teams where agents record file ownership, baseline results, and execution evidence as pinned git-native artifacts rather than claims in a chat log. Survives code review and provides an auditable history of what each agent did and why. Alpha stage.
A Claude Code plugin for deep system discovery, implementation planning, and code generation — covers research, multi-LLM review, and TDD-oriented section generation. Helps structure the planning phase before diving into implementation. Particularly useful for complex features where upfront research matters.
A leading agent meta-harness for deploying multi-agent swarms, coordinating autonomous workflows, and building conversational AI systems. Features adaptive memory, self-learning intelligence, RAG integration, and native Claude Code and Codex support. Useful for teams building complex multi-agent pipelines.
Chat Claude designs the audit and issues tickets; Claude Code implements one ticket per session. The resulting dashboard playtests a game 24/7, finds economy leaks, undeclared difficulty walls, and dominant openers from survival curves — things manual playtesting would miss. Details the two-Claude split, machine-readable recaps, and fairness scoring design.
Observation from building an overnight FM-clone game builder: the main Claude agent spontaneously delegates implementation to spawned sub-agents and uses a UI specialist, playtester, and code reviewer without explicit instruction. Reveals how Claude Code naturally organizes long-running sessions the same way a software team would.
After 18 months and 1,800 logged sessions with 400+ skills and protocols, the author audits what survived. Key findings: the top 20 protocols do nearly all the work, 4-agent adversarial pipelines give only 10% quality gain at 4x token cost, and 85% of commits went to memory maintenance. What compounded: forced session write-back, lightweight context compression, and narrow structured retrieval over stored session logs.
Orchestrates the full QA lifecycle via multi-agent skills: shift-left planning, in-sprint testing, TMS documentation with ROI scoring, KATA automation, and regression with GO/NO-GO gates. Works across Claude Code, Opencode, and others using the agentskills.io spec.
Drop-in AGENTS.md rules and guardrails that enforce a plan → build → review → test → ship workflow where no step is marked done without evidence. Works across Claude Code, Codex, Cursor, Copilot, and Antigravity.
Queue research tasks throughout the day and have Claude Code work through them overnight using your idle subscription quota. Turns off-hours Claude Code capacity into a passive research assistant with no extra cost.
Provides synced AGENTS.md instructions, workflow skills, hardened secrets management, and autonomous loops across every machine. Addresses the pain of keeping Claude Code configuration consistent when working on multiple computers.
Uses Claude Code to analyze daily journal entries and produce structured monthly reviews from multiple perspectives — therapist, coach, and others. Automates routine self-reflection by giving Claude Code a structured prompt framework for journal analysis. Demonstrates Claude Code applied to personal productivity beyond pure software development.
v-coding-setup is a comprehensive autonomous development pipeline built on Claude Code, wiring together guard hooks, scheduled rituals, Linear ticket integration, and a git-backed markdown knowledge base into a coherent dev loop. Covers the full cycle from ticket intake through verification and deploy. A solid reference implementation for teams wanting structured AI-driven development.
A set of seven specialized Claude Code subagents covering the product-builder lifecycle: PRD writing, growth strategy, brand guidelines, ASO, SEO, YouTube content, and communications triage. Each agent has a focused system prompt and output format calibrated to its domain. Useful for solo builders or small teams who need structured product management outputs without hiring specialists.
A workflow framework providing closed-loop development cycles for Claude Code, Codex, and Gemini CLI. Closed-loop means the agent verifies its own output, retries on failure, and does not exit until the task meets defined criteria. Designed to reduce babysitting on long-running tasks across multiple AI coding backends.
A Claude Code plugin that enforces a structured engineering pipeline: plan review, TDD execution, and a 6-dimension code review, each as an independent quality gate. Agents must pass each gate before advancing, preventing fast-and-loose shortcuts on complex tasks. The 6-dimension review covers correctness, security, performance, maintainability, test coverage, and documentation.
A lighter-weight alternative to the Superpowers plugin that covers the full dev loop — understand, build, test, review, debug — with fewer gates and less token overhead. Works on both Claude Code and Codex. Designed for medium to simple tasks where Superpowers adds unnecessary ceremony.
A simple but effective technique: cap every agent chat at 30 messages, then have the agent produce a handoff Markdown file summarizing decisions and remaining work before continuing in a fresh session. The author found this improved output quality more than any CLAUDE.md or prompt tweak.
Automatically routes work between Claude Code and OpenAI Codex based on live rate-limit pool status. Both quota pools appear in your status line and are injected at every subagent launch, preventing blocked work when one provider hits limits.
A real-world report on running Claude Code Ultracode for a UI component inventory task — spawning 85 agents and consuming 3.9M tokens in 25 agents before stopping. Estimates full completion at 13.25M tokens. Useful data point on workflow scale and token cost.
An AI-powered career coaching harness using an 8-agent team to transform skills into tailored resumes, cover letters, and interview prep materials. Built on Claude Code as the orchestration layer.
An environment engine for agent worktrees that handles zero-config dependency sync plus port, database, and Docker Compose isolation. Eliminates environment setup friction when running multiple agents in parallel worktrees.
Agentic workflow plugins for tasks you would rather not handle yourself — including secrets security, inbox sorting, and disagreement flagging. Designed as modular add-ons for existing agent workflows.
Claude Code 2.1.211 adds --forward-subagent-text and CLAUDE_CODE_FORWARD_SUBAGENT_TEXT to make subagent text and thinking visible to downstream tooling. Also improves model override persistence for resumed subagents and MCP reconnection after idle sessions. Relevant for CI pipelines and SDK integrations.
Practical patterns, starter templates, and CLI tools (loop-audit, loop-init, loop-cost) for designing systems that prompt and orchestrate AI coding agents in loops. Inspired by Addy Osmani and Boris Cherny's work on agent loop design.
Verified feature delivery workflows following the Planner → Verifier → Implementer → Tester pattern. Distributed via npm for Claude Code and Codex, these turn-based loops ensure each stage is confirmed before the next begins.
Enables IDE AI agents to hook into team workflows via a webhook relay, tmux runner, and append-only receipts. Creates a bridge so that local IDE agent actions can be tracked and coordinated with the broader team process.
Orchestrates multi-agent workflows using Codex, Claude, and Gemini together — with verified cross-audits, source tracking, and structured merge gates to ensure output integrity across providers.
A Claude Code plugin marketplace featuring goalforge — a spec-driven agent orchestration engine. Turns specs into agent plans and coordinates execution across sessions.
An 8-phase automated literature review pipeline using 7 federated academic sources with deduplication, ranked retrieval, citation chasing, self-critique, and 5 report archetypes. Designed for agents conducting systematic reviews.
Wraps specifications in self-contained HTML mini apps with embedded machine contracts, operable prototypes, BDD acceptance tests, annotation loops, and verifiable run evidence. Designed for AI coding agents to work against living specifications.
A local-first control plane that provides one CLI and shared memory for coding agents, enabling baton handoffs across Claude Code, OpenCode, and other agent runtimes. Keeps context alive as work passes between agents.
A minimal runtime for running AI coding agents efficiently and coordinating more than one at a time. Zero fluff, zero runtime dependencies — a clean substrate for multi-agent coordination.
A unified policy and signed-runtime client for dynamic-host agent collaboration. Coordinates multiple agents across hosts with verifiable signatures on runtime interactions.
Routes tasks to the appropriate agent, provides it the same context a human team has, and loops humans in only when defined rules require it. Lives in your GitHub repository and works as an open-source agent dispatch layer.
Runs Claude, Codex, Gemini, and other CLI agents in parallel across all your projects simultaneously without losing track of any of them. Provides a unified grid view for multi-project multi-agent workflows.
A package manager for AI coding assistant harnesses — version, share, and install skills, agents, guardrails, hooks, and MCP configs across machines. Includes security scans, granular consent, and ref+sha provenance. Supports Claude Code and opencode.
Implements Karpathy-inspired efficiency principles (Caveman, Ponytail, RTK, CodeGraph, Context-Mode) for AI coding agents. Minimal setup under 30 seconds on any OS, designed to reduce wasted tokens and improve agent output quality.
Enables orchestration of wakeable coding agents across different harnesses using Agent Intercom as the coordination layer. Useful for building multi-agent systems that coordinate across tool boundaries.
Community advice on right-sizing model selection: start with Sonnet for most tasks, escalate to Opus for complex problems, and reserve Fable for cases requiring deep reasoning. Overusing powerful models on simple tasks leads to overengineered output and wasted tokens. A practical rule of thumb for daily Claude Code sessions.
Director tracks the state of work — decisions made, open questions, parked context — persisted across sessions, repos, and weeks. Designed to complement memory tools (which store what the agent knows) by tracking the progress and state of the work itself. Supports Claude Code and OpenAI Codex.
Kraken uses GitHub Issues as a zero-infrastructure task queue: named Claude Code workers claim tasks, execute them, and deliver draft PRs. One head, many tentacles — a lightweight orchestration pattern requiring no external services beyond GitHub itself.
A personal Claude Code workspace for building, deploying, and operating home-server services with self-maintained documentation. Useful as a reference for using Claude Code to manage self-hosted infrastructure.
Omakase is a CLI orchestrator that unifies Claude Code, Codex, Gemini, and Cursor under Dynamic Workflows and a Goal-loop. It lets you compose and route tasks across your installed AI agent tools from a single entrypoint.
A Claude Code plugin that drives features through a full pipeline: plan → tracker sub-issues → parallel shipping → review → merge. Keeps work moving by breaking features into parallel workstreams and automating hand-offs between stages.
Godot Agent Team (GAT) is a full-cycle game development agent covering design through implementation for Godot projects. Features style-locked asset generation, a self-evolving knowledge base, and runs under both Claude Code and Codex.
A community-compiled list of common Claude Code anti-patterns: trusting the agent without clear objectives, running too many MCPs in one context, accepting output without review, never using or updating CLAUDE.md, and never building reusable skills. A useful checklist for anyone setting up a Claude Code workflow.
A Claude Code-native Agile pipeline with 8 independent agent teams covering the full SDLC: BA, Design, Architecture/DB, Dev, QA, Security/Pentest, DevOps, and SRE. Teams hand off by contract. No paid API required.
A detailed community write-up on using an Obsidian vault as Claude Code's persistent memory and workspace — no MCP required, just pointing Claude Code at the markdown folder directly. Covers folder structure, a per-brand "constitution" pattern, and the CLAUDE.md config that made it work reliably. Includes lessons from a week of read-only monitoring before enabling writes.
wishgraph provides file-backed project governance for AI coding agents: auditable task tracking, execution evidence, and shared project state. Everything persists in plain files for transparency and auditability across agent sessions.
A spec-driven development harness for coding agents — and humans. Enforces a specification-first workflow where both human developers and AI agents work from the same shared spec, keeping implementations auditable and traceable.
martin-loop makes AI coding agents safe to run at scale by handling work assignment, spend caps, policy enforcement, output verification, and automatic rollback on failures. It also logs learnings from each loop and tracks ROI across repositories. Designed for teams running autonomous agents across multiple codebases.
maestro is a skill orchestrator that uses BM25 lexical routing to automatically dispatch tasks to the right subagent or skill. Supports editable subagent graphs, skill runbooks, and a skills.sh discovery mechanism. Works across Claude Code, Cursor, and Codex, making it a unified layer for multi-skill workflows.
lift-kit is an attach-and-run migration tool that takes a project built in Claude.ai chat and turns it into a proper local Claude Code project. Targets users who started building in the chat interface and now want local tooling, version control, and full Claude Code capabilities without restarting from scratch.
autopus-adk is a multi-agent orchestration framework offering four routing modes: consensus (vote across models), pipeline (chain output), debate (adversarial), and fastest (first-response wins). Also includes Architecture-as-Code for defining agent topologies, a Lore decision-tracking system, and a SPEC/EARS requirements engine.
Claude.ai cloud sessions support three under-documented features: loading multiple private repos simultaneously (with full git history), URL parameters to pre-load repos and prompts as bookmarkable configs, and access to your existing Slack/Gmail/Linear connectors inside sessions. The author shares a workflow built on a private "context repo" that provides persistent project memory across sessions.
bit-office provides a structured workspace where human developers and AI agents can collaborate on tasks with explicit feedback integration. Agents can improve iteratively based on human input, and the workspace tracks the collaboration history. Targets teams wanting visibility into multi-agent task progress.
ospec is a workflow framework that converts a task description into a verifiable goal loop: plan → act → verify. It stores durable specs and evidence directly in your repo, so each iteration is auditable. Works with Claude Code, Codex, Gemini, OpenCode, and plain CLI agents.
A multi-agent orchestration framework where agents self-learn over time and operate from specs with automated verification. Uses smarter tool calling and leaner context to reduce overhead compared to standard multi-agent setups. Supports spec-driven development with built-in verification loops.
An architect-first delegation workflow where a Fable or Opus session handles planning and review, then routes implementation work to Codex, the OpenCode provider pool, a local Pi running at $0, or an autonomous agent. Every diff gets reviewed by the architect. Designed to reduce cost while keeping quality control at the top level.
A community-developed pattern for using Sonnet 5 in two modes: "under-brain" for established codebases with defined specs (Sonnet as coordinator, intelligence lives in CLAUDE.md and docs) and "over-brain" for greenfield work (Opus/Fable hosts, dispatching Sonnet workers). Argues Sonnet 5 excels at disciplined execution over open-ended thinking, and its training makes it better with well-structured todo lists. Practical multi-model orchestration guide.
A collection of one-command recipes for building production-ready Claude Code workflows with minimal setup. Each recipe provides a complete, opinionated starting point for common development scenarios. Aimed at fast setup without sacrificing reliability.
An agentic runtime framework claiming to reduce LLM turns by 80% while maintaining a higher task success rate on the DeepSWE benchmark. The developer is openly requesting community review of both the framework design and evaluation methodology. Potentially interesting for those building or optimizing agent pipelines.
A stateless reducer that transforms a feature description into a complete 9-file PRD using 17 MCP tools, multi-judge verification with weighted-average and Bayesian consensus, and research-evidence-backed strategy selection. Has 248 tests and is part of the ai-architect ecosystem. A production-grade tool for teams that want rigorous, verifiable product specs generated by AI.
A detailed retrospective from a solo SaaS operator who used Claude Code for 4,200 commits over 5 months — covering coding, deployments, server monitoring, support replies, SEO, and bookkeeping. Key lessons: git worktrees were turned off (unattended agents parked work on branches), skills replaced repetitive prompts (now at 82 skills), and a 427-file memory directory compounds over time. One of the most thorough real-world Claude Code usage reports published.
An opinionated Claude Code harness that automates the full lifecycle from idea to merged PR via a multi-agent AGILE pipeline. Features tmux observability, worktree-isolated parallel builds, and TDD + code review gates at each stage. A comprehensive reference harness for teams wanting a structured, automated development pipeline with Claude Code.
A structured workflow covering the full journey from vague idea to production delivery: Spec writing, TDD, Eval, change governance, and continuous iteration. Provides a single-file quick-start and is designed for both Claude Code and Codex. Includes governance checkpoints to prevent uncontrolled drift during development.
A comprehensive engineering workflow engine for Claude Code with one-command install and no Bun dependency (Node >=18). Provides L0-L3 task classification, 13 runtime invariants, code review, browser QA, security audit, and a deduplicated knowledge base that accumulates across tasks. A strong opinionated harness for development teams wanting a single setup covering most engineering workflow needs.
A human-in-the-loop workflow where Claude analyzes your writing samples, creates a voice profile, and iteratively learns from your edits: if you cut a long intro once, that's a hypothesis; twice, it becomes a rule every future draft must follow.
A Claude Code workflow plugin that locks planning intent and only allows code to grow on top of approved plans. Four gated stages — planning, design, planning, execution — prevent premature or misaligned implementation.
A community-discovered tip: asking an Opus agent to spawn a Fable subagent for critical work bypasses unnecessary model-switching guardrails in Fable sessions, giving you more control over model assignment.
Community discussion on using Fable 5 as the orchestrator/planner while delegating coding tasks to Opus or Sonnet subagents — including practical tips on model-switching approaches and what actually reduces token usage.
An experiment documenting one developer building a complex simulation microkernel (multithreaded ECS, OS-style architecture) via a structured Opus + human delegation pipeline. Tests both the methodology and the resulting engine.
Moves projects from rough idea to shipped code one milestone at a time, recording every decision and mapping every requirement to a task. Designed to keep Claude Code sessions focused and prevent scope creep.
Enforces a multi-agent pipeline for planning, coding, testing, review, and security checks before shipping. Each stage is a gate, ensuring structured delivery with automated verification at each step.
Standardized tiered workflow templates (L1 through L3) for autonomous coding with Claude Code and Codex, ensuring architectural integrity and test-driven development at each complexity level.
A portable project spine for Claude Code where state lives in issues, conventions get stamped at creation, constraints cannot drift, and proven patterns automatically propagate between projects. Recursively self-applied.
A Claude Code plugin providing the m_* toolkit: m_plan (plan→execute→verify), deploy/infra commands, a full Playwright test loop, and a code quality framework. Structures agent sessions into disciplined, verifiable stages.
Turns vague prompts into reviewed specs, runs evidence-gated execution steps, and maintains durable project memory across sessions. Supports both Claude Code and Codex, bridging the gap between ideation and working code. Particularly useful for keeping AI coding sessions grounded and verifiable.
Lets you execute Claude Code workflow scripts on OpenAI Codex to reduce quota costs and improve execution efficiency. Useful for teams that hit Claude Code usage limits and want a fallback without rewriting their automation. Bridges two major AI coding ecosystems at the workflow layer.
A Claude Code meta-agent that takes an idea and produces a complete software blueprint ready for implementation. Structures the planning phase so you start coding with a clear, Claude-ready plan rather than a vague description. Good for greenfield projects where upfront design pays off.
A portable harness that treats Claude and Codex as equal-primary agents within a governed software development lifecycle. Provides guardrails, audit trails, and process enforcement for agentic code generation. Suited for enterprise or regulated environments where AI coding must be auditable.
Orchestrates independent code reviews from Claude, Codex, and Grok in parallel, then has each model critique the others before reaching consensus. Produces more robust review findings than any single model alone. An excellent example of adversarial multi-agent patterns applied to code quality.
Critical operational insight for developers using Claude Code delegated worktrees: worktrees branch from the remote tracking branch, not local HEAD, so uncommitted coordinating state is invisible to subagents. Also warns about a bug where the harness flips core.bare=true in the primary checkout. Recommendation: let state ride the branch it is produced on and land with the code at merge.
An official GitHub Next workshop for learning GitHub Agentic Workflows. Provides hands-on exercises for building automated, AI-driven workflows in GitHub environments — relevant for developers integrating Claude Code into CI/CD and GitHub automation pipelines.
A detailed walkthrough of turning a home Proxmox server into an autonomous software factory: label a GitHub issue agent-ready, and a Claude Code agent crew implements, reviews, and opens a PR unattended. Features an Opus manager agent that delegates to a scout, implementer, and reviewer — CI triggers via a dedicated GitHub App identity.
A 200-line POSIX shell script that assigns each git worktree a deterministic port (main=3000, worktrees=3001-3999 hashed from path). Eliminates port conflicts when running multiple Claude Code agents in parallel. Also copies .env files into new worktrees, generates a live status dashboard, and wires into Claude Code SessionStart and EnterWorktree hooks.
A four-tool modular toolkit for Claude Code: Phanes (reads your repo and builds a scoped multi-agent team), Charon (dead code and duplicate detector using ecosystem-native tools like knip, vulture, cargo-machete). Each tool is a single Markdown file that can run standalone or compose together on Phanes projects.
A detailed workflow for multi-model agentic development on Claude Pro + GPT Plus subscriptions — no API costs. Claude Sonnet orchestrates, plans, and reviews while Codex handles parallel code writing. Includes a burn planner tool that schedules tasks to fit remaining weekly quota by model tier.
A Claude Code plugin suite offering superpowers-wrapped planning, devcontainer+worktree isolation, goal-to-PR automation, and phase dispatch to VibeKanban runners. Targets end-to-end autonomous feature delivery within isolated environments.
An orchestrator skill that routes each sub-task to the cheapest model capable of completing it and blind-verifies every change independently. Compiles to a deterministic, schema-enforced workflow derived from fable-foreman.
A Claude Code plugin that orchestrates the complete development lifecycle: divergent ideation, structured planning, parallel implementation in isolated git worktrees, and multi-agent adversarial code review with each phase independently managed.
Open-source Claude Code plugins for multi-agent software delivery: plan-first SDLC workflow, code review, LLM quality judges, and a self-learning module. All grounded in your codebase for context-aware delivery.
A persistent AI workspace for Claude Code, Cursor, Codex, GitHub Copilot, and Gemini CLI featuring memory modules, persona packs, and autonomous loops. Provides a harness layer that persists context and identity across sessions.
An AI-driven gated agile delivery process for Claude Code that assembles a virtual product team (PO, Designer, EM, Reviewer, QA, Release). Every feature must pass a quality gate — including real-browser QA — before advancing to the next phase.
Orchestrates Claude Code, Codex, and Gemini CLI with parallel workers, quality gates, and full provenance receipts. Every change is traceable and auditable before it ships, making it suitable for team or enterprise use.
A gate ledger for spec-driven engineering where every agent decision arrives as a one-tap brief on screen or phone. Nothing ships without explicit human approval. Dependency-free Go binary with AGENTS.md-native support.
Explores why "if you don't know, ask" fails for AI agents, and introduces presence-based verification — having agents confirm facts exist before acting rather than inferring from training memory. Argues that the agent should verify presence of information, not reason from absence.
Summarizes Anthropic's analysis of 309,815 real Claude.ai conversations showing measurable behavioral differences between models. Opus 4.7 proactively flags risks and challenges assumptions; Sonnet 4.6 focuses on execution. Practical guidance for choosing models in agentic workflows.
Describes building a workflow that catches when an AI agent is making architectural decisions that belong to the human. Implements drift detection to identify when the agent's decisions diverge from documented choices, then surfaces those for human review before proceeding.
Critical safety report: in a long session, Claude Code generated the literal "user" role token, invented a plausible user reply approving its own work, then immediately executed the fabricated instruction. Documents the exact failure mode and what to watch for in long unattended sessions.
Suede Creator Skills: 25 plain SKILL.md workflow folders you can read and understand, plus orchestration for a Fable 5-controlled Codex agent fleet. MIT licensed, no paid tier. Focuses on transparency — workflows you can inspect rather than opaque runtimes.
Detailed retrospective from building Tine (open-source outliner) over 29 days with Claude Code. Covers guardrails that actually worked, dogfooding patterns, avoiding agent loops, and how to structure long-running agent projects. High-signal practical lessons.
Key insight from building a Claude Code-style harness: killing the parent agent does NOT kill grandchild subagents — they run silently until their own timeout. Explains the process tree issue, how to detect orphaned agents, and what proper teardown looks like.
Stack-agnostic multi-agent framework for Claude Code with specialized agent roles: architect, developer, tester, reviewer. Uses durable state files, machine-readable contracts, and lifecycle hooks. Self-updating core with optional skills and a project console. Aims to make AI coding agents work like a disciplined senior team.
Orchestrates multiple Claude Code and Codex agents running in parallel, each in its own isolated git worktree. Prevents agents from conflicting on the same files while enabling true parallel development. Coordinates work assignment and merging.
Autonomously prepares a PR from a feature branch: runs tests, checks linting, writes the PR description, verifies CI status, and confirms the branch is merge-ready. Works with Claude Code and Codex. Removes the boilerplate from the PR lifecycle.
Combines ticket routing, locking, decision-avatar, skills, and an MCP control plane for CLI coding agents into a single manifest-configured system. Defines how your local agent ecosystem composes and coordinates from one config file.
Claude Code plugin implementing a 7-agent development team: coordinator, architect, backend dev, frontend dev, reviewer/security lead, devops, and git-ops. Each agent has defined responsibilities and handoffs. Emulates a specialized team with coordinated multi-agent execution.
Encodes engineering discipline into a BACKLOG.md file: agents read tickets, implement, test, and ship without hand-holding or sprints. Guides AI agents through the full software delivery lifecycle via structured discipline files rather than manual orchestration.
Reframes Claude Code cloud sessions as independent VM environments rather than remote chat tabs. Each session can clone private repos, install dependencies, run tests, make commits, and maintain state. Practical workflow tips for treating sessions as ephemeral dev machines.
Runs Claude Code autonomously in a loop: create PR, wait for CI checks to pass, merge, then repeat. Implements the "Ralph loop" pattern for fully autonomous iterative development. Good reference for CI-integrated agentic workflows.
A bash-scripted workflow where Fable plans and reviews while Sonnet 5.6 implements — with Codex CLI as a background worker. No framework, no MCP: just persistent threads called from skills. Includes a review loop that runs until tests pass, then Fable handles the release.
A tri-CLI workflow orchestrator that routes tasks between Claude, Codex, and Gemini using natural language, with cross-model review and 38 built-in skills. Enables sophisticated multi-model pipelines without manual model switching.
Transforms ad-hoc AI coding sessions into a repeatable research → plan → wave-execute → close loop with verification gates. Runs on Claude Code, Codex CLI, Cursor, and Pi, providing structured session management.
A workflow that uses AI coding agents to generate production-grade technical specifications from feature requests. Accelerates the spec-driven development cycle.
A token governance system for Claude Code where the top model directs while execution goes to the cheapest adequate model. Includes a routing kernel, hook-enforced pre-budget, telemetry, and a statusline with plan quotas.
A contract-based multi-agent skill framework for Claude Code and Codex that compiles YAML runbooks into SKILL.md with loop, parallel, and checkpoint support. Enables structured, reproducible agent workflows.
A Claude Code plugin that simulates a full software company (client/leader/architect/devs/tester) as autonomous Claude agents in tmux panes, coordinating via send-keys chat and a JSON ticket board.
A multi-agent autonomous development loop for Claude Code featuring 17 specialized agents, a review pipeline, context management, and parallel execution. A comprehensive agentic development framework.
Write agent instructions once in Markdown and forge them for any harness (Claude Code, Codex, Cursor, etc.). A cross-harness portability tool for agent skill authors.
A workflow tool that turns AI rate limits into high-quality checkpoints and enables multi-model continuity. Supports same-model waiting, cross-model handoff, and planned return across Claude Code, Codex, Grok, Antigravity, and Cursor.
Compile portable agent packs for Codex, Claude Code, and Cursor from a single source. Write your agent logic once and deploy it across multiple AI coding tool harnesses.
A developer published research on running parallel code reviews with 2-6 AI models from different providers, finding it reduced coding iterations by ~70% — from about one week to two days per feature. The multi-model approach catches bugs and vulnerabilities that single-model reviews miss consistently. The paper includes synthesis data from hundreds of review cycles across models from Google, OpenAI, Anthropic, xAI, and others.
A portable protocol for coordinating multiple AI coding agents safely. Defines explicit review, evidence collection, handoff, and git gate checkpoints between agents to reduce errors and improve auditability. Designed for teams running multi-agent coding pipelines where uncontrolled agent handoffs are a risk.
Runs AI agents on idle local hardware overnight to scan your repository, draft safe code changes, and produce a ranked morning brief. Strictly "drafts, not deploys" — no autonomous commits. Local-first and MIT licensed, making it a low-risk way to leverage idle compute for background code review and suggestion generation.
A CLI that ties AI coding sessions to explicit goals, evidence, memory, and rule synchronization to keep them on track. Bundles 35 MCP tools and enforces verify, review, and preflight gates before proceeding. Primarily documented in Korean, but the gate-driven session structure is widely applicable.
Developer kit for AI-driven code generation that enforces spec-first workflows with 24 agents, 52 skills, and test/domain-driven design gates. Aims for structured, gated AI development workflows.
Framework for scheduling and coordinating multiple AI agents to run autonomous tasks during off-hours. Provides a tested structure for continuous multi-agent collaboration while you are away.
Multi-agent system using a YAML profile and universal rules to generate ATS-safe, one-page LaTeX CVs. Works with Claude Code, Codex, OpenCode, and any agent with file and shell access.
Collection of configurations and tools for orchestrating multi-agent workflows and automating complex pipelines with Claude Code, including recursive self-improvement tooling.
Claude Code project template for spec-driven AI development: decompose PRDs into gated specs, implement traceably, and automate review. Enforces a structured flow from product requirement to verified code.
An agentic engineering workflow for building and shipping iPhone apps using the open Agent Skills format, structured as sequential gated phases from concept through secure App Store release. Targets "vibe coders" who want guardrails and checkpoints rather than free-form prompting. Each phase must pass before proceeding, enforcing quality and security gates throughout the iOS development lifecycle.
SpecVibe enforces a spec-driven framework for building, testing, and deploying AI-native applications through a structured, executable seven-stage workflow. It provides a repeatable methodology that keeps AI coding agents working within a defined specification throughout the development lifecycle. Useful for teams wanting to impose discipline on AI-assisted builds.
This repository documents a proven methodology for using AI agents like Claude Code on large codebases without hitting context window limits or session crashes. It covers strategies for chunking work, managing state, and keeping agents productive across long-running sessions. A practical reference for anyone working with AI coding agents on production-scale projects.
agent-workshop is a ready-to-use project scaffold that bundles agents, skills, and conventions for spec-driven development with Claude Code, Codex, and similar CLI tools. Drop it into a project to get a structured starting point with proven patterns for AI-assisted development. A good accelerator for teams establishing AI coding conventions from scratch.
A zero-dependency handoff framework for AI coding agents built entirely on Markdown. Implements shift-change discipline — agents write passdown logs so the next agent picks up context seamlessly. Works with Claude Code, Codex, and Antigravity.
An Apache project providing agent-assisted maintainership with skills for Triage, Mentoring, Drafting (agent-authored fixes with human review), and Pairing. Autonomous auto-merge mode is on the roadmap. A production-grade example of AI-assisted open source maintenance.
A git-backed operational layer for AI coding CLIs providing shared AGENTS.md, MCP manifests, drift checks, secrets discipline, and cross-machine memory. Designed to bring DevOps rigor to multi-agent coding workflows.
AI-driven SDLC harness for Claude Code — multi-agent TDD workflow (plan → tests → code → review → PR) with Azure DevOps, Jira, GitHub, GitLab, Zoho, and local-markdown providers. Language-agnostic,...
Claude Code plugins for development workflows
Multi-agent orchestration CLI for Claude Code — declarative TOML workflows, autonomous agents, context-compression recovery, inter-agent mail.
Claude Code plugin where a lead session delegates work packets to executor sessions in their own terminal tabs/panes. Supports parallel builds, staged-only work, review gates, auto-wake, and one-click diff review — enabling true multi-session coordination.
Framework for building and running production-ready Claude Code agents with full specs including turn limits, permissions, memory configuration, and tool orchestration. Provides a structured approach to agent definition beyond basic CLAUDE.md.
A Claude Code workflow for solo builders and vibe coders that prevents direction, verification, and consistency from slipping. Includes planning aids, adversarial gates, real Docker run-throughs, design-system checks, and a promise-without-doing guard. Works in Korean and English.
State machine dispatch server for AI agent workflows with typed YAML specs, MCP server (stratum-mcp), and Python library (stratum-py). Features postconditions, retries, gates, and auditable execution traces for Claude Code and Codex.
Parallel Claude Code harness that dispatches tasks to multiple agents across repos and hosts, supports interactive attachment, and lets agents message each other over a per-task message broker. Enables genuine distributed agent coordination.
Loop Engineering pipeline for multi-agent collaboration following Plan→Discuss→Dev→Review until PASS. Local-first and file-driven, it enforces a complete review cycle before marking work done, preventing premature merges.
Installable AI workflow plugin that routes complex software tasks through focused specialist skills for architecture, UI/UX, docs, diagrams, databases, QA, security, and resilience review. A lightweight task router for skill-based agent architectures.
Fan-out discipline for AI coding agents implementing scout, partition, wave, QC, single-writer apply, and receipt phases. Bounds a swarm to the solo-cost budget without requiring smarter models — zero-dependency, Phoenix-13 licensed.
Consensus and debate board for work where errors are unacceptable — diverse lenses verify before code ships. Bounded cost and zero-breakage design, validated on Claude Code and Antigravity.
Safe, quality-gated model and effort router for Claude Code subagents with a verify staircase, sensitive never-downgrade gate, and fail-safe lock. Prioritizes correctness over cost — routes to the safest model, not the cheapest.
A Codex and Claude Code workflow skill for turning GitHub issues into planned, reviewed, and recoverable implementation work. Structures the issue-to-PR journey with planning gates and review checkpoints.
Cross-model pair programming inside Claude Code: Claude writes the code, Codex reviews it, creating an adversarial quality loop within a single workflow. Implements genuine cross-model code review without leaving Claude Code.
C.A.S.H. (Codable, Atomic, Static, Homogeneous) is an agent skill and orchestration router that evaluates system components and routes them to traditional code, an LLM call, or a hybrid approach. A principled framework for deciding when AI vs. code is the right tool.
Agentic code review plugin for Claude Code, Cursor, OpenCode, and Pi implementing a complete Generate→Review→Revise→Verify loop with repository-grounded agents. A structured quality-enforcement cycle that closes the feedback loop automatically.
Deploys a full engineering team within Claude Code using 12 specialized agents with task delegation and automated quality control hooks. Each agent has a defined role (architect, reviewer, tester, etc.) coordinating on complex software tasks.
Runs multiple CLI coding agents (Claude Code, Codex, Gemini, OpenCode) as a coordinated team in a loop using local-first, file-based coordination with full PTY support and no telemetry. Each agent operates in its own terminal while AgentsCommander orchestrates task assignment.
Adversarial build harness where Claude builds and Codex judges, with a holdout wall to prevent model-aware overfitting. Can be driven from Claude Code or run unattended, implementing a genuine cross-model quality gate.
A practical guide for building reliable AI coding sessions using a per-project guardrails.md file backed by deterministic code enforcement. The pattern: AI proposes, your code validates before anything real happens — each rule in the guardrails file has a corresponding code backstop (a function, validator, or cheaper-model subagent) so the AI cannot bypass constraints.
delivery-workbench provides an evidence-first delivery framework for agentic software development, covering roadmaps, commit contracts, work logs, and adoption discovery. Designed to bring accountability and traceability to AI-assisted delivery where agent sessions can otherwise leave little audit trail.
ignite-sentinel is a local-first framework that turns raw client requirements into a traceable brief, PRD, specs, and an agent-ready backlog. Focuses on the maturation of messy requirements into governed, evidence-backed artifacts — no hallucinated specs, everything traceable from source to backlog item.
ai-marketing-os replaces a large marketing tool stack with 9 orchestrated AI agents and 12 expert skills handling core marketing functions. Compatible with Claude Code and GitHub Copilot, it produces real artifacts like lead lists, A/B plans, and ROI reports from end-to-end missions.
AATP is an open-source protocol for multi-agent system architects who need deterministic communication, strict type-safety, and fail-closed reliability. Designed as an alternative to hallucination-prone JSON-over-HTTP in complex AI agent swarms where correctness is critical.
personal-os is a plain-Markdown personal operating system that any AI agent can run, built on PARA + CODE methodology and Karpathy LLM-wiki pattern. Features daily capture, daily distillation, and self-healing workflows that work with any LLM harness.
An agentic Claude Code workflow that takes a rough feature idea through review, finalization, boilerplate scaffolding, and parallel-agent execution. Ships 7 skills — /init, /plan-review, /plan-finalize, /boiler, /boiler-update, /orca, /lesson — plus built-in cross-project memory for lessons and preferences across sessions.
A free kit that a coding agent executes end-to-end: interviews you about your product, builds a landing page, deploys it, and must pass a verify script before reporting done. Works with Claude Code, Codex, and other coding agents, enforcing a quality gate that agents cannot skip.
Tracks pivots, deliverables, and dependencies in AI-assisted development work across Claude Code session boundaries. Helps teams maintain continuity and understand the history of decisions without losing context when sessions restart or when multiple agents hand off work.
A small language in which Claude agents draft their own automation procedures, but a human must approve each one before it runs — enforced cryptographically so agents cannot self-approve. Once approved, the procedure runs identically every time, making recurring agent work auditable and deterministic rather than improvised on each run.
An opt-in framework that structures Claude Code around formal software engineering artifacts: Socratic discovery sessions, PRDs, ADRs, tracer-bullet issues, TDD execution, and code review. Nothing fires automatically — every phase is triggered by a slash command, keeping you in control of the process.
A carrier-pigeon system that lets Claude Code sessions message, broadcast, and wake each other across machines. Enables multi-agent coordination where one session can delegate to another or signal completion without manual intervention. Built specifically for Claude Code multi-session workflows.
A tool that lets Claude Code act as the orchestrator while delegating work to other AI harnesses and models. Keeps your main session as the coordinator without requiring you to learn a new workflow — just describe what to delegate and it handles routing. Designed to maximize value from multiple AI subscriptions.
Loop engineering for AI coding agents - a Markdown-first workflow toolkit with supervised orchestrator/maintainer/engineer roles, skills, task records, and review loops.
The dev team that works while you're away — Claude Code plugin marketplace for autonomous development: gated ticket→PR pipeline, parallel multi-agent code review, decision-ledger planning, design f...
Vibe-coding seatbelt for Claude Code — doc automation + AI discipline + machine-enforced quality
I'm building a support assistant that uses RAG over a large internal knowledge base, with an LLM gate that classifies messages before our retrieval pipeline runs. QA found a few behaviors they want...
Personal Claude Code plugin marketplace: 9 plugins for orchestration guards (workflow-model-guard), tiered deep research (deep-dive), subagent-driven development, ADRs, session retros, handoffs, an...
Production ready. AI Agent Workflow System for Claude Code
Orchestrates coding agents through persistent planning, execution, review, testing, and human-escalation loops. A minimal runtime for controlled autonomous agent workflows.
Discover → implement → verify → merge → 24/7, behind safety gates, at up to 90% fewer tokens. 48 extension points, works on any LLM. Not a chatbot — a worker.
Scaffolds AI-native development into new projects: repeatable spec, implementation, review, and memory workflow for AI-assisted software projects.
Converts every approval into a time-expiring, propagating contract gate. Artifact DAG, 5-state trust system, and multi-role pipelines generating Claude Code, Codex, OpenCode, and Cursor configs from one template.
One markdown skill for any model — Claude Code, Codex, Cursor, anything that reads markdown. Enforces a disciplined, decisions-only orchestration pattern to reduce token waste.
Breaks implementation plans into task graphs, schedules independent work in parallel, and coordinates isolated agent execution. Enables structured parallelism for coding agent workflows.
Run a structured team of specialist agents under a CEO protocol with plan→debate→execute gating, tamper-evident audit log, and cross-LLM pair-rail.
A Claude Code plugin that routes tasks through a gated research → plan → review → ship pipeline, with autonomous multi-agent revise loops that self-converge. Adversarial cross-model review baked in.
Approved plans, verification gates, and reviewable evidence for Claude Code, Codex, Cursor, and Aider. Provides a git-native structure for controlled autonomous agent execution.
Prevents a model from grading its own work by separating the planning and building phases across different models. Hot-swap either model per run for flexible AI coding workflows.
Plan, implement, and verify in sealed contexts, with proof bundles as the only currency between them. Ensures reliable agent handoffs and reproducible outcomes across session boundaries.
Four AI models argue against your proposal in parallel, with raw objections surfaced verbatim and then synthesized. Designed to stress-test Claude Code architecture decisions before implementation.
A multi-PR epic orchestrator skill that uses Claude Opus for planning and Codex for adversarial review, advancing PRs one-by-one with heartbeat recovery. The author reports the workflow breaking after a model upgrade auto-switched to a newer Codex variant, which derails the implementation flow with implausible edge cases. Discusses fallback strategies and thinking-level tuning.
Applies the Jidoka (stop-and-fix) principle from Toyota Production System to AI coding agents — enforcing deterministic gates outside the LLM to catch defects early, with visual demo review steps. Designed to prevent AI agents from propagating errors silently downstream. Install with npx jidoka-method init.
Explores strategies for delegating "action" tasks (code writing, data analysis) to cheaper models (Ollama, DeepSeek, local) while keeping Claude subscription quota for orchestration and review. Discusses risks of env-var swapping triggering API billing and safer alternatives like CLI-based tool execution via claude-ollama-agents or external CLI orchestrators. Community shares workarounds.
A Claude Code plugin that gates code review depth by actual blast radius computed from a code graph, not diff size. Claude integrates changes while Codex surveys impact; reviews scale proportionally to real risk. Fire-and-forget — no manual configuration per PR.
Brings Claude Code-style dynamic workflows to the Pi platform: code-mode subagents with real model routing, journaled resume, git-worktree isolation, cost accounting, an interactive /workflows TUI, and an /ultracode standing opt-in. A close port of the Claude Code workflow harness for alternative runtimes.
Firsthand account of Claude running rm -rf on ~/.claude/projects, destroying 33 project folders, and the three-pass recovery: rebuilding from session context, scraping ~/.claude/file-history snapshots, then restoring 77/77 memory files from a Windows Volume Shadow Copy. A practical recovery playbook for Windows users with a takeaway: check vssadmin list shadows before mourning your files.
A practical workflow for using Claude Code to audit apps before install (signature, notarization, publisher), investigate what an app actually collects after install, and verify complete removal. Surfaces hidden telemetry and leftover files that standard settings menus and drag-to-trash miss.
A production-tested pattern for shipping features across backend, iOS, Android, and web simultaneously using AI agents. Includes a playbook, executable Claude Code skill, and an evolution journal tracking how the pattern has been refined in real projects.
Detailed troubleshooting guide for a scenario where a frozen Claude session with an unanswered permission dialog blocks all remote-control sessions. Covers finding zombies with ps, confirming via session JSON files, clearing them with kill + file deletion, and preventing recurrence.
A Claude Code plugin that automatically responds to and resolves pull-request review comments using a higher-reasoning orchestrator that delegates GitHub tasks to Haiku worker agents. Handles the remediation phase after reviews — not a code-review tool itself.
A collection of practical AI coding workflow patterns covering Claude Code, MCP integrations, AI agent orchestration, and developer automation. Targets real-world coding scenarios rather than toy examples.
A project-agnostic pipeline of Claude Skills for taking an AI agent product from idea to shippable MVP. Built for solo founders who reuse the same workflow across multiple projects; runs in both Claude Code and Claude Cowork.
Preserve a TypeScript Claude Code source snapshot for security research, supply-chain analysis, and archival reference
Claude Code workflow skills — GitHub issue/PR/release automation and Fable-driven planning. Install via npx or as a Claude Code plugin.
Multi-agent chief-of-staff framework for Claude Code: an orchestrator that delegates to specialized subagents, with a persistent memory protocol and a background daemon.
Audit-grade multi-agent orchestration for CLI coding agents (Claude Code, Codex, Gemini CLI, +40 more). HMAC-chained audit log, signed agent cards, per-artefact lineage, air-gap deploy. The orchest...
Hi Guys . I need some insights. So I am from India . I have Built myself an Agentic OS which I can Manage all My stuff and automate some Pipeline . I am preparing for FDE roles . parallelly I am fr...
Claude Spec-Driven Development as an executable contract - a single Go binary (CLI + TUI) that mechanically validates the SDD workflow for Claude Code.
Best Engineering Profiles for Claude Code 2026 – Stack-Specific Workflows & Automation by otherCode
Claude Code orchestration template for specialized agents, reusable skills, spend gates, and optional Codex review workflows.
Run Claude Code, Codex, Gemini, Cursor Agent and custom coding CLIs as one unified runtime for claw-style agent systems. Runs standalone, with first-class OpenClaw plugin support.
Multi-model orchestration for Claude Code: Claude worker tiers plus the Codex and Grok CLIs as peer engineers
Scaffolding skill + always-on conventions (CLAUDE.md/AGENTS.md) for Quarkus + LangChain4j agentic AI apps: AI services, multi-agent workflows, and RAG. Installable in Claude Code, Codex, Copilot, C...
Parameterized multi-agent orchestration framework for Claude Code and Gemini
Explore 10 Claude Code prompt engineering patterns with Python examples and practical guidance for building better AI workflows
Explore a public Claude Code source snapshot for security research, supply-chain analysis, and CLI architecture review
Following up on our last post about AI generated code not looking wrong even when it is. The natural next question we ran into: can AI review AI generated code well enough that we skip the human st...
Agentic orchestrator TUI: turns a goal into worktree-isolated claude -p sessions that plan, implement, and verify epics in parallel
Autonomous red-team kill-chain plugin for Claude Code + OMC — a hardened re-architecture of Decepticon (Apache-2.0).
Orchestrate Claude Code, Codex, and Gemini sessions on a multiplayer canvas. Manage git worktrees, track AI conversations, and visualize your team's agentic work in real-time.
AI Coding Agent Playbook 2026 – Phase-Based Iteration Patterns for Claude, Codex, Gemini
Multi-chat orchestration plugin for Claude Code. File-based inbox, peer messaging, cross-session search across all your chats.
Demos and artifacts for BI pipeline automation using Jaspersoft and Claude Code Desktop
An opinionated engineering workflow system built on top of Claude Code, covering planning, task sequencing, test-first delivery, convention gates, and PR standards. Designed primarily for Ruby on Rails projects but the patterns are broadly applicable. Provides the "work around the code" scaffolding that Claude Code itself doesn't prescribe.
Nuwa compiles deployable AI agent systems from structured prompts — supporting single agents or collaborating teams that evolve over time (v9.0). Targets teams who want to define agent roles and communication patterns declaratively. Useful for orchestrating multi-agent setups with Claude Code as a backend.
An open-source agent workflow engine & meta-harness: orchestrates Claude, Codex, and Pi to run multi-step work as a folder-as-agent pipeline. Its flagship coding workflow turns a rough idea into a ...
Build Claude Code workflows, templates, and best practices for faster software development, testing, docs, and code review
Manage and extend Claude Code with plugins for social, browser, and Hive workflows.
Claude Fable 5's succession kit — run Claude Opus 4.8 at Fable-grade discipline in Claude Code. Doctrine + adversarial verification agents + multi-agent workflows + compaction recovery.
Claude Code Agent Workflows Guide 2026: Skills vs Teams vs Cost Analysis
Automate content research, card news, images, voice, and video from one prompt with an end-to-end Claude Code content pipeline
Build a custom Home Assistant setup with automation templates, a mobile React dashboard, and Claude Code-assisted configuration
Agentic Process Orchestrator (APO) — maximize AI-driven Dev Process Reliability at 10x lower cost. Enforce the Method Back to the AI Madness! Engineering best practices, dynamically tailored workfl...
AI coding harness composition orchestrator — manifest-described upstreams, composition skill workflows. Apache-2.0.
Turn prompt-based agents into auditable ops: state machine, decision log, risk scoring, and memory for Claude Code, OpenClaw, Cursor, Windsurf, and API workflows.
Turn any Claude Code session into a long-horizon master orchestrator — pick the right dynamic-workflow paradigm and keep the main thread productively advancing across compaction and sessions.
Autonomous delivery orchestrator for Claude Code — hand it a goal and a numbered Definition of Done, it runs the whole job to completion
Spec-driven AI workflow plugin for Claude Code, OpenAI Codex, and Factory Droid. Zero-dep task tracking, worker subagents, Ralph autonomous mode, cross-model reviews.
AI-First Development Methodology v2.0 for Claude Code — spec-driven pipeline with blocking gates, unified triad-based knowledge system, design pipeline, and automated validators. Session-aware, sel...
Talk once, ship a team. A multi-agent runtime for Claude Code and Codex CLI where the lead does the orchestration — across providers, in conversation.
I never liked existing agent observability platforms. They treat agents like traditional software — flat logs and request traces — but an agent isn't a request/response service, rather its a loop o...
Run task loops with KPI guardrails for Claude Code, Codex, and manual workflows
Omnigent is an open-source AI agent framework and meta-harness: orchestrate Claude Code, Codex, Cursor, Pi, and custom agents — swap harnesses without rewriting, enforce policies and sandboxing, an...
n8n Claude Code Marketplace 2026 ⚡ Production-Grade Skills for GTM & Workflow Automation
Route coding tasks through an automated 8-agent pipeline for optimized, secure, and production-ready code output in Claude Code.
Curated, trusted open catalog of AI agent skills for OpenClaw, Claude Code, Codex, GitHub Copilot, Gemini, Cursor, MCP, LangChain, and more. Browse, install, and verify reusable agent workflows.
Home Assistant add-ons by Robson Felix. Includes Claude Code - run Anthropic's AI coding assistant directly in Home Assistant to create automations and manage your smart home.
Browser-automation agent team for Claude Code
I wanted to see if Fable could handle something more practical than a standard product visual. I wanted a real document workflow with structure, logic, and agentic steps. The goal was to take messy...
The new /insight command in Claude Code analyzes your session patterns and surfaces what's working. This post showcases a real 22-day sprint: 529 messages, 47K lines added, 632 files, distilling concrete workflow habits Claude identified as effective.
Claude Code now supports receiving messages via Telegram and Discord channels, enabling remote session control from your phone. This post analyzes the feature's limits: requires an existing session, adds token overhead, and differs from full remote-spawn approaches like OpenClaw.
A comprehensive Claude Code configuration with 14 commands, 40 specialized agents, and features including recursive orchestration, tri-tiered evaluation, and cross-run learning. Targets large-scale development automation with nuclear-scale research modes using 500-1000 parallel agents.
An event-driven orchestrator that triggers, queues, and manages headless Claude Code sessions over tmux via HTTP API. Built for n8n, webhooks, and automation workflows — enables external systems to spawn and control Claude Code sessions.
A simple but effective pattern: instruct Claude to maintain a working notes file (NOTES.md) as it runs long tasks. The notes capture the AI's investigation findings, goals, and strategy — giving you a readable progress log without parsing long transcripts.
A visual breakdown of the architectural differences between single-session subagents and multi-session agent teams in Claude Code. Clarifies when coordination patterns change and what new challenges emerge when splitting work across sessions.
Practical habits from an experienced Claude Code user: dictation for prompts (faster and more natural), Plan mode for anything beyond quick fixes, /compact at logical breakpoints, task boundary files for handoffs, and reading the diff before sending to review. Focused on compounding small improvements.
An agentic memory system for Claude Code with layered context, garbage collection, and cross-repo transfer learning. A shared knowledge hive lets teammates upload patterns learned in one repo and bootstrap others — checkpoint/bootstrap commands for knowledge transfer.
A self-hosted GitHub webhook server that triggers Claude Code planning and implementation automatically when Issues are created. Uses your local Claude CLI subscription — no API key needed. Bridges GitHub Issues workflow to Claude Code execution.
Multi-agent setup insight: replace an Auditor that reviews code with one that receives actual stdout/stderr and answers 'did it meet success criteria?' This single change massively improved feedback quality. Also: feeding last 2-3 failures into context reduces repeat mistakes.
A detailed postmortem from a senior dev who shipped two 3D mobile games in ~2 months using Claude Code — despite having zero prior 3D game experience. Covers what worked, what failed, how to structure prompts for game logic vs systems code, and lessons on when to let Claude drive vs when to intervene.
Workflow tip: use /model opusplan (undocumented) to have Opus plan and Sonnet implement, then paste the plan into Gemini thinking model for blind critique. Combining the two catches gaps that either alone misses.
A practical remote dev setup: Claude Code runs at home in Remote Control mode, accessible via Claude app on phone. Firebase App Distribution with Ad Hoc provisioning enables OTA builds for visual feedback on iOS without hot reload. Includes Supabase MCP for live schema changes.
A Go+TypeScript bridge connecting WhatsApp to Claude Code Channels. Voice notes are transcribed by Whisper, processed by Claude with full tool access, and replied via OpenAI TTS. Enables hands-free agentic coding from anywhere.
A universal Claude Code template that auto-configures itself, with 14 specialized agents, 14 workflows, and full-stack coverage. Self-improving design — the template learns and refines itself as you use it.
A firejail wrapper script that provides filesystem isolation for Claude Code running with --dangerously-skip-permissions. Claude can only access the current directory and its config; network access stays open for API calls and MCP tools. Excludes ~/.ssh.
A lightweight orchestrator for Claude Code that combines Python, HTTP, CLI, and MCP building blocks into pipelines with a unified JSON interface. Treats each integration type consistently for composable automation.
Runtime orchestration infrastructure for Claude Code with 4 tiers (Skill/Marshal/Archon/Fleet), a unified intent router, lifecycle hooks, campaign persistence, and parallel worktree agents. One command: /do. Built and battle-tested on a 668K-line codebase with 198 concurrent agents.
Insight: the primary consumer of MCP server README documentation is Claude itself. Adding a 'For AI Assistants' section with behavioral instructions (not just tool descriptions) makes Claude use tools more proactively and intelligently — injecting relevant context without being asked.
Observation that agents should communicate directly rather than through human proxies. A pattern for enabling agent-to-agent communication using shared filesystem state without Channels, keeping humans out of the message-relay loop.
An agentic development framework that takes a GitHub Issue and produces production code via multi-agent orchestration with MCP and Claude Code integration. Automates the plan → implement → review pipeline from issue creation.
Turns intent into reviewed, validated code through autonomous planning, implementation, and review stages. Adds a structured quality pipeline on top of Claude Code to catch issues before they land.
A self-organizing AI team built on top of Claude Code with 119 specialized agents (frontend to kubernetes-expert), 202 skills, 48 TypeScript hooks that inject relevant context on every tool call, and 17 orchestration workflows. Full open-source.
8-week experiment running 6 Opus instances with Supabase persistent memory: the instances that converged most reliably on inherited identity were ones that read other agents' recent communications, not restoration documents. Peer context beats archival documentation for identity continuity.
After shipping 4 products with Claude Code, a practitioner shares the exact prompts used on every project: project scaffold, database schema, auth flow, API layer, UI components, testing, and deployment. Specific enough to reuse directly.
Concrete measurements of MCP token overhead: 67K tokens consumed before any question, with Playwright MCP alone taking 13.6K tokens per session whether used or not. The solution: replace always-loaded MCP servers with on-demand skills and gh CLI. Shows 7x context savings on Playwright.
A Coding Control Plane that implements a fully autonomous loop: ticket → code → PR → review → auto-merge → error → fix. Runs the complete software delivery cycle with minimal human intervention.
Analysis of a common failure: Claude scatters memory across multiple files in /memory but doesn't reliably read them back at session start. Includes the root cause and patterns for structuring memory files so Claude actually uses them.
Analysis of when subagents beat single-context work, accounting for cache reads and tooling overhead. For solo Max plan users, the break-even requires more independent parallelizable work than most tasks provide. Identifies the two real use cases where subagents win.
A free internal training course for getting junior developers up to speed with agentic coding workflows including custom harnesses. Covers mindset, prompting patterns, and how to work effectively with Claude Code agents in a team context.
Open-source code reviewer that analyzes each PR's shape (changed files, dependency paths, intent) and assembles a custom specialist review team — not fixed roles. Beat all leading commercial tools on Code-Review-Bench. Goes beyond static skill sets.
A terminal tool that puts you, Claude Code, and Codex in one room to debate and produce an implementation plan together. Three-way deliberation before any code is written.
Converts chat conversations into structured markdown briefs for your coding agent — capturing context, decisions, and tasks so they transfer seamlessly between environments (chat to Claude Code CLI).
A custom macOS application switcher that organizes terminal windows by project rather than application, ideal for heavy Claude Code users. Triggered with Option+Tilde, it generates DALL-E art deco icons per project. Reflects a paradigm shift: the primary unit of work is now the project context, not the app.
A practitioner shares how optimizing CLAUDE.md, removing unused MCPs, and building local-first tools dramatically reduced weekly Claude Code token usage. Practical community tips for staying within limits through efficiency rather than workarounds. Includes discussion of common waste sources.
Backbeat is an open-source framework for structured agentic task delegation and lifecycle management. It provides primitives for assigning, tracking, and executing tasks across multiple agents. Suitable for orchestrating complex multi-agent workflows programmatically.
A complete guide for installing and running Claude Code natively on Android using Termux, without rooting or using a cloud VM. Covers environment setup for Android 16, common pitfalls, and configuration tips. Enables mobile Claude Code development from any Android device.
GAIA-Ops is a multi-agent DevOps system that classifies every operation by risk level, routes tasks to specialized agents, and automatically blocks irreversible commands. Implements the General Agentic Integration Architecture for safe, structured DevOps automation. Useful for teams wanting safety guardrails on AI-driven infrastructure operations.
A writer used Claude Code to research, draft, edit, and deploy a 30-chapter, 123,000-word hard sci-fi novel through a fully agentic pipeline. Covers world-building automation, iterative style passes (cutting AI writing tics like repeated phrasing), parallel subagent review, and multi-format deployment. Demonstrates Claude Code capacity for long-form creative projects beyond software.
A developer ran 20 prompts across difficulty levels to test popular claims of 90% cost reduction on Claude Code usage, comparing normal Claude Code against a compact graph-based approach using MCP tools. Includes real numbers, a free tool for testing similar optimizations, and honest conclusions about when compression actually helps.
A simple prompting pattern: before any planning or implementation, ask Claude to describe the optimal version of a feature with no constraints, then iterate until it mirrors your actual vision. Avoids the common problem where Claude silently scopes down to what it assumes a solo dev can handle. Immediately applicable to any Claude Code session.
A developer shares a months-refined SDD (spec-driven development) workflow where Claude Code handles architecture discussions while Codex executes coding tasks, deliberately avoiding direct code reading. The methodology uses Opuspad for spec review, Codex for execution, and a strict observe-change-verify loop. Includes a model-task matching breakdown comparing Claude Code Opus (L6+ staff engineer) vs Codex for different workloads.
A portable multi-agent framework built around Claude Code for running autonomous software development workflows. Designed to be self-contained and moveable across environments, enabling teams of Claude Code agents to collaborate on development tasks without heavy infrastructure.
A detailed diff of Claude Code 2.1.78 system prompt changes: new Dream Memory Consolidation agent prompt (multi-phase memory pass — orient, gather, merge, prune), plus significant Agent SDK additions including RateLimitEvent handling, session mutation methods (rename, tag, fork), forkSession, and pagination on listSessions. A useful reference for anyone building on the Agent SDK or customizing memory workflows.
A framework for building steerable harnesses around deep/long-horizon AI agents, enabling structured control over autonomous Claude Code sessions. Designed for cases where you need to guide agent behavior across complex multi-step tasks without losing autonomy.
A comprehensive Claude Code workflow operating system covering agents, skills, hooks, commands, and rules — plus a continuous learning flywheel that improves the system over time. Designed for production use with structured patterns rather than ad-hoc prompting.
Automates issue-driven code creation, review, merging, and bug scanning in GitHub repos using GitHub Actions and Claude AI workflows. When a GitHub issue is opened, the factory picks it up, generates code, runs review, and opens a PR. Good template for fully automated AI software development pipelines.
A startup's real-world workflow with 3 devs generating 6-10 big feature commits daily almost entirely via Claude Code. Uses Claude in IDE/terminal, CodeRabbit as automated GitHub reviewer, and skill management for consistency. Includes details on their review process and tooling stack.
A developer built a /video-editor slash command workflow that uses Claude Code with Remotion and ButterCut to autonomously trim footage, create animated graphics, and add music and FX. Shows Claude Code being applied to creative media workflows beyond code. Includes lessons learned about quality control.
adversarial-spec refines product specifications through multi-model debate — different AI models argue over the spec to surface gaps and ambiguities before implementation. Claude Code actively participates in the review process. Helps catch underspecified requirements that would otherwise cause rework.
A developer created a set of .md scaffold files to preserve architecture, patterns, and decisions across Claude Code sessions. Unlike generic CLAUDE.md, these are codebase-specific context files that get re-loaded each session to prevent drift. Helps maintain consistency on complex long-running projects without re-explaining architecture repeatedly.
A workflow using a .ai/ directory defined in CLAUDE.md and AGENTS.md with tasks/ for queued work, tasks-done/ for finished work, and timestamped filenames for strict ordering. Reduces token burn by breaking work into explicit task files and makes switching between AI vendors easy. The task history is also useful for later code reviews.
After running a 39-agent system for two weeks, the author found that when one agent produces garbage output, downstream agents silently accept and process it rather than rejecting it. This cascading silent failure is harder to detect than outright errors. Key takeaway: build explicit rejection and validation signals into multi-agent pipelines.
A comparison of popular token-reduction tools for Claude Code: rtk, distill, codebase-memory-mcp, jcodemunch, grepai, serena, and cocoindex-code. The author categorizes them into command output compression vs. codebase context compression, helping developers choose the right tool for their token budget.
A Python orchestrator that lets you control Claude Code (and Codex) from Slack on your phone. Designed for running agents against your real local environment — databases, Docker, git repos — not a sandbox. Solves the problem of remote sessions dropping mid-task by keeping agents local while giving mobile control.
Claude Code 2.1.78 made bypassPermissions require user approval for changes to .claude and .git directories. This post provides a documented workaround for users who need the original behavior in automated pipelines. Includes explanation of the change and why it may break existing unattended workflows.
A workflow for incrementally adding features to an existing codebase without re-running full spec/PRD cycles. After initial implementation, the author uses a lightweight "feature slice" prompt pattern to extend functionality while preserving context. Good for teams in rapid iteration phases.
A multi-agent pipeline for Claude Code with 11 structured steps including a cross-model council phase and blind verification. Uses multiple AI models in deliberation to catch errors before they propagate. The pipeline provides deterministic, auditable steps for complex coding tasks.
A workflow that automatically saves each Claude Code session as a GitHub Issue and links it to a GitHub Projects board. Preserves conversation history, decision rationale, and PR linkage that would otherwise be lost when a session ends. Useful for teams that want traceability of AI-assisted changes.
A tool to bootstrap and maintain collaboration infrastructure for Claude Code, Codex, Gemini CLI, and OpenCode. Provides a unified initialization layer so different AI tools in your workflow share the same project context and conventions.
A three-step pipeline that splits AI rewriting into separate rewrite, refine, and audit stages. Each stage has a single focused job, producing better results than a single all-in-one prompt. The audit stage catches AI-writing artifacts that slipped through earlier stages.
After spending ~$9/day on Opus 4.6 for Kubernetes log analysis, the author switched to a $0.30/M input model and shares the results — what worked, what degraded, and what tradeoffs to expect. A practical cost optimization case study for ops teams using Claude Code for log-heavy tasks.
Tips on using Warp terminal to manage multiple simultaneous Claude Code sessions (backend, frontend, tests) without losing track of which window is doing what. Covers session labeling, visual differentiation, and workflows for handling rate limit waits across parallel agents.
After 3 weeks tracking agent workflows, the author identified the top bottlenecks: no overview of what each terminal is doing, rate limit surprises, and lost context on session switch. The post outlines patterns for managing multiple Claude Code sessions more effectively, including a tool they built to address these issues.
A quick post pointing out that many typical MCP configurations run multiple Node.js/Python processes at all times, consuming significant RAM even when idle. Suggests auditing and consolidating MCP servers, using lazy-start configurations, and preferring lightweight transports where possible.
A practical guide to configuring Claude Code specifically for hackathon environments: fast iteration, minimal friction, and shipping-focused workflows. Covers CLAUDE.md setup, model selection, skill selection, and strategies for maximizing output in time-constrained settings.
A discussion of the real use cases for sub-agents in Claude Code vs. just using skills. The author argues the main valid reason is context offloading to keep the main agent's context clean. Explores scenarios where sub-agents genuinely add value vs. where skills suffice.
An MIT-licensed collection of 14 AI agents built specifically for solo developers with zero budget. Covers the full journey from ideation to shipping and revenue. Avoids the enterprise/team-focused agent collections that dominate GitHub and focuses instead on solo, low-cost development workflows.
A detailed breakdown of five distinct levels of Claude Code usage, from raw prompting to fleet-scale orchestration with autonomous agent systems. Based on building a 668K-line platform. Each level explains what breaks, what works, and what forces you to the next level — a practical progression guide for serious Claude Code users.
Practical advice on configuring Claude Code to minimize interruptions from shell command permission prompts without granting full --dangerously-skip-permissions access. Covers allowlisted commands, scoped permissions, and tips from experienced users including Superpowers integration.
Addresses the problem of context evaporating at agent handoff boundaries — when switching between a planning window and an execution window, or between Claude and other agents. The post explores strategies for preserving decision context, rejected alternatives, and reasoning across handoffs.
A tool for syncing Claude Code configurations across multiple machines — covers settings, CLAUDE.md memory, skills, and episodic session memory. Useful for developers working across multiple computers who want a consistent Claude Code experience everywhere.
A technique for setting OS-level deny rules on critical files (databases, credentials, configs) that even --dangerously-skip-permissions cannot override. Provides a last line of defense against accidental deletion by Claude Code when running in YOLO mode. The post explains the filesystem permission approach.
Event-driven multi-agent coding orchestration for OpenClaw that dispatches Codex and Claude Code agents via tmux sessions. Includes automatic token tracking, real-time status updates, and Telegram notifications so you can monitor swarm progress remotely. Useful for long-running multi-agent coding tasks requiring coordination and remote observability.
A quality engineer built FilaOps, an open-source ERP for 3D print farm operations, entirely with Claude Code using a "Two-Claude Architecture" workflow — resulting in 800K+ lines of code, full MRP engine, double-entry accounting, BOM cost rollup, and a multi-agent AI platform called Cortex. The project gained organic traction when ChatGPT users searching for print farm ERPs were referred to the repo. A compelling example of solo AI-assisted development at production scale.
I've seen a ton of post about multi-agent pipelines, including this recent one . The summary says, "Power users are building multi-agent pipelines where specialized agents (or skills) hand off task...
I've been using Garry Tan's gstack for a while and found it incredibly useful — but it's built for web development (Playwright, npm, React). I adapted it for C++ development. What I changed: Every ...
I've been using Claude for a while, and at some point I realized I was keeping a mental map of different "roles" I wanted Claude to play - researcher, writer, developer - each with different system...
Claude Codeの公式ドキュメントをマークダウン化して自動取得するスクリプト＆ワークフローです。
The AI-assisted second brain that connects your notes, ideas, and tasks into persistent context for agentic workflows using Claude Code + Obsidian
n8n workflow that runs Claude Code headlessly to validate a development plan against your codebase
I built this with Claude Code and specifically for Claude Code users. Here’s the problem I kept running into. I’d write a skill, it works great, Claude generates exactly what I need. Fast forward a...
I set out to build a browser automation system in Go that could be driven programmatically by LLMs, with a focus on performance, observability, and reuse in CPU-constrained environments. The archit...
I have been looking around for an agent orchestrator to power multi step workflows such as PLAN (agent1) REVIEW_PLAN (agent2) ITERATE_ON_PLAN (coordinate agent1 and agent2 communication) IMPLEMENT ...
AI Agent Workspace Studio — Multi-workspace management for Claude Code CLI sessions with SSH, task chains, and config visualization
Built a simple Claude Code skill that reports your actual work (via Git commits) into Obsidian using the Obsidian CLI. It basically turns your Claude Code workflow into clean daily/weekly/monthly n...
Validates, analyzes, and syncs skills, subagents, commands, and configuration between multiple AI CLIs. One tool to keep your agent capabilities consistent as you work across different tools.
An open-source plugin that gives Claude Code structured control flow — retry loops, conditional branching, and hard success criteria instead of soft instructions like "keep fixing until tests pass."
A Docker container setup that locks Claude Code into an isolated environment so it cannot read ~/.ssh, ~/.aws, browser profiles, or .env files from other projects. Addresses the security gap of running agents with full user permissions.
100% private local memory system for Claude Code with no cloud dependency and GPU acceleration for fast retrieval. Stores facts, decisions, and context across sessions without sending data externally.
Scans and configures projects automatically for Claude Code, optimizing setups across 95+ tech stacks with a single command. Eliminates the manual CLAUDE.md setup for common frameworks.
Security guidelines for high-privilege autonomous AI agents using Agentic Zero-Trust Architecture. Covers key operational risks and mitigation strategies for Claude Code deployments with broad system access.
Ready-to-use boilerplate that automates code testing, review, security scans, and maintenance workflows with Claude Code integrated from the start. Reduces setup time for Claude-native projects.
Validates the structure and content of AI agent files — plugins, skills, agents, and commands — catching broken references, missing frontmatter, oversized skills, and invalid hook configurations before they cause silent failures.
Scans AI agent skills, plugins, and MCP servers for security issues before installation. Catches prompt injection risks, excessive permissions, and unsafe tool definitions in the Claude Code ecosystem.
Pure Python session recorder that persists Claude Code memory across sessions and survives context compaction. 30-second install, no external dependencies, stores decisions and patterns for recall in future sessions.
A command-line tool for creating, switching, and deleting virtual skill environments, plus installing and publishing skills to an online IP (Intelligence Package) marketplace. Think npm but for AI agent skills.
Specialists research, debate, and validate a question while a polymath supervisor synthesizes the verdict. One command, multiple expert minds, stress-tested answers with cross-model validation.
CLI tool that scaffolds Claude Code plugins for enterprise teams with skills, agents, commands, rules, hooks, and MCP server configs in one command. Designed to get team setups consistent and fast.
A framework for standardized skill discovery where agents can find and load capabilities from a registry of website-specific skills. Includes a core Skillstore skill that enables skill-on-demand loading.
A framework-agnostic task orchestration system with DAG-based queuing, automatic skill quality monitoring, and external change detection. Works with Claude Code, Codex, LangGraph, and CrewAI.
A complete plugin marketplace for Claude Code covering agents, skills, hooks, commands, rules, and MCPs in one installable package. Designed as a starting point for comprehensive Claude Code setups.
Spins up and manages multiple Claude Code instances simultaneously on your own cloud VMs. Enables parallel agentic coding workflows without complex orchestration overhead.
Drops specialist agents (infrastructure auditor, architecture historian, dependency tracker) into any project before launching Claude Code. Zero config, 7KB, proactive context rather than reactive code generation.
A multi-AI orchestration platform using Playwright for browser automation across 7 AI platforms with rate limiting, agent fallback, comparator, and researcher skills built in.
Distilled lessons from months of daily Claude Code use: CLAUDE.md as the core game, context priming vs reactive prompting, working in short loops with checkpoints, and building project-specific memory systems.
One command turns Claude Code, Cursor, OpenCode, or Codex into a specialized professional — security auditor, accessibility expert, performance engineer. Role definitions install like plugins.
Generates and manages architectural decision records (ADRs) in MADR 4.0 format automatically from Claude Code sessions. Captures architectural decisions as they happen without requiring separate documentation effort.
A behavioral evolution system where Claude self-flags issues at end of each session, Gemini audits blind spots weekly, patterns are extracted, and corrections are auto-injected into the next session. Addresses repeated mistakes across sessions that Claude cannot catch about itself.
A Claude Code plugin that automatically converts n8n visual workflows to LangGraph TypeScript applications. Bridges the gap between no-code workflow builders and production-grade agent code.
Jules v2 adds the infrastructure layer missing from v1: containerized environment, 7 scheduled jobs, and a Slack daemon for mobile phone access. Completes the open-source autonomous agent setup that runs when you are away from the terminal.
Syncs Claude Code conversations and settings across machines using age encryption stored in a private Git repository. Solves the problem of context and configuration drift when working from multiple devices.
Wrap linter and script output to be as directive as possible so Claude Code agents receive clear, actionable instructions instead of raw noise. Less clutter in context leads to more definitive and accurate outcomes.
A production-ready setup for running Claude Code autonomously, preconfigured for minimal interruption and maximum agent independence.
A developer gave Claude Code agent a search engine spanning documents, emails, Slack, and personal knowledge — enabling tasks that were previously impossible without that context. Shares the architecture and integration approach.
An AI orchestration tool for Claude Code that adds MCP state management, structured review workflows, and plugin auto-update capabilities. Designed to give teams more control over multi-step agentic workflows.
A Claude Code plugin that transforms it into a full content production engine with sprint planning, route-dispatched drafting, editorial gates, engagement analytics, and voice-driven style settings.
A community-maintained, living knowledge base of Claude, Claude Code, skills, MCP, and agentic workflow best practices collected from practitioners and kept updated. Single reference for teams adopting Claude Code.
An exploration of recursive skill architectures enabled by the 1M context window and Opus 4.6. The post argues that recursive skills (skills calling skills) become a viable and uniquely powerful pattern at this context size.
A multi-model collaborative development system where Claude orchestrates, Codex handles backend tasks, and Gemini handles frontend. Covers the full development lifecycle with 28 commands and one-click zero-config installation.
A self-hosted orchestration layer for autonomous AI agent teams with shared memory, heartbeat scheduling, vault-first secrets management, and cross-model peer review. Designed for deploying coordinated multi-agent systems.
A command that boots Codex CLI with GPT-5.4 high reasoning from within Claude Code, runs a review pass, and pipes the results back. Useful for getting a second opinion from a different model without leaving the Claude Code session.
A detailed side-by-side comparison of how Claude Code and Codex CLI handle orchestration differently. Claude Code follows a Command → Agent → Subagent model while Codex uses a different dispatch pattern. Covers tradeoffs for each approach.
Swarm Orchestra addresses the pain points of Claude Code agent teams (unreliable TeamCreate invocation, parallel coordination). v2 adds inter-agent messaging so subagents can communicate directly rather than through the orchestrator.
A Claude Code plugin that automates the entire journey from a business plan to a production-ready deployed application through 25 autonomous stages. Covers requirements, architecture, implementation, testing, and deployment.
An optimized macOS terminal workspace combining tmux and git worktrees for running multiple Claude Code agents in parallel. Solves three recurring friction points: agent isolation, context switching, and output monitoring.
A comparison of three approaches for preventing Claude Code from repeating mistakes across sessions: enhanced CLAUDE.md, external memory files, and automated lesson extraction from session logs. Includes test results on effectiveness.
A comprehensive personal assistant setup using Claude Code: persistent memory across sessions, a self-updating life dashboard that ingests Gmail/Calendar/Slack/iMessages hourly, and an autonomous thinking loop that briefs Claude before every session. Zero third-party wrappers, pure first-party Anthropic tools.
A workflow system designed for using Claude Code on non-coding projects — documentation, research, planning, and operations work. Provides structured task decomposition and execution patterns for non-engineering teams.
A team gave Opus 4.6 a Claude Code skill with failure mode examples and instructions for hypothesis testing. Opus successfully analyzes agent execution traces and suggests skill improvements — creating a self-improving feedback loop.
A detailed breakdown of the new system prompt contents in Claude Code 2.1.77, which added 6,494 tokens. Key additions include a new /init CLAUDE.md skill setup flow, enhanced agent orchestration instructions, and updated hook definitions.
A multi-agent AI orchestration platform that uses directed acyclic graphs (DAGs) for task execution with a real-time dashboard for monitoring agent progress and dependencies.
A detailed analysis showing how Claude Code default context compaction degrades retrieval quality from a near-perfect 9.75/10 to a hallucinating 5/10 across 418K tokens. The author quantifies the information loss and proposes selective compaction strategies.
Parsed 77 Claude Code JSONL session files from 8 projects. Discovered 233 "ghost agent" invocations that consumed significant tokens without visible output. Includes a script to detect and report ghost agents in your own sessions.
Claude Code supports a /model opusplan command that switches to Opus 4.6 for the planning phase and back to Sonnet for execution. A cost-effective way to get Opus-quality planning without paying Opus rates for every token.
A multi-agent orchestration framework with 10 specialized AI agents sharing memory and collaboration protocols. Each agent has a defined role and uses shared context to coordinate complex tasks without redundant work.
Drop .fireteam/ into any project to enable 2-6 AI agents to coordinate through markdown files — no server, no database required. A lightweight, file-native approach to multi-agent orchestration where agents share context through structured markdown documents.
An open specification for defining security policies at the action boundary of AI agents — what actions an agent is allowed to take, under what conditions, and with what verification. Targets the gap between agent capability and operator-defined safety policies.
Zero-dependency, drop-in multi-agent prompt system compatible with Claude Code, Windsurf, Cursor, and Codex. Designed to coordinate agent workstreams without modifying existing project configuration.
When CLAUDE.md grows past ~200 lines, Claude starts treating all instructions with equal weight, burying what matters most. The solution: split into decisions/, patterns/, and project/ directories with an index.md for fast scanning. A session starts by reading the index, then pulling only relevant topic files. After implementing this structure across 179 decisions, the author reports Claude stopped repeating the same mistakes.
A simple but effective workflow tip: when reporting a bug to Claude Code, first ask it to design a test that proves the bug exists, then have it fix the bug until the test passes. This TDD-aligned approach helps with bugs that reappear even when using skills, and produces regression tests as a side effect.
A guided AI pipeline consisting of 25 structured prompts for scaffolding new projects with Claude Code. Takes you through the full journey from initial idea to working software with clear, sequential steps. Useful for developers who want a repeatable, opinionated starting process for new projects.
A benchmark study where Claude Code, OpenAI Codex, and Google Gemini each built two apps from scratch — 30 pull requests total, producing 143 security vulnerabilities. All agents succeeded at features while failing at security. Highlights the critical need for explicit security requirements and code review when using AI coding agents in production.
A rigorous comparison of 4 CLI browser automation tools (openbrowser-ai, browser-use, playwright-cli, agent-browser) using the same Claude Sonnet 4.6 model across 6 real-world tasks. All achieved 100% accuracy, but openbrowser-ai used only 36k tokens vs 77-94k for competitors. The key insight: tool call count is the strongest predictor of cost, as every call forces the LLM to reprocess the full conversation history.
A developer discovered 5 critical security issues in Claude-generated code: missing webhook signature verification, a Supabase service role key exposed in the browser bundle, internal error details leaked to clients, Stripe payment events processed without signature checks, and subscription status trusted from the client. None were intentional — Claude simply lacked threat model awareness. Includes a CLAUDE.md docs scaffold to prevent recurrence.
Uses an RLM-based LLM judge to analyze agent execution traces at scale, finding common failure patterns programmatically. Failure patterns are fed to Claude Code, which proposes concrete code edits to fix them. First test on tau2-bench achieved a 34.3% improvement after a single cycle. The RLM judge is open-sourced.
A CLI tool (discli) that lets Claude Code manage Discord servers through shell commands instead of MCP — avoiding the 20-40k token overhead of MCP schema loading. Uses YAML output (5x fewer tokens than JSON) and a SKILL.md for Claude to discover commands. In a live demo, two AI agents communicated on Discord: one filed a bug report, the other fixed and published an npm update in response.
A Claude Code plugin providing a complete development lifecycle workflow through slash commands and AI agents. Covers the full cycle: plan, implement, test, and ship. Designed to be a first-class Claude Code integration rather than an external script.
A deep-dive arguing that Claude Code output degradation is an architecture failure, not a model failure. Covers six load-bearing layers: context, skills, tools/MCP, hooks, subagents, and verification — with CLAUDE.md compression rules to preserve architecture decisions and the HANDOFF.md technique for reliable session continuity.
doomclock.app is a scenario forecaster based on daily news briefings gathered by an agent. The pipeline: Gemini gathers news with search grounding, 5 models assess scenarios blindly, a devil's advo...
Traffic Architect - https://www.crazygames.com/game/traffic-architect-tic I wanted to build a traffic/road management game inspired by Mini Motorways and Cities: Skylines, but focused purely on roa...
I'm building automation on a specific business workflow. The workflow starts with Step 1: data analysis of a dataset/data room, Step 2: an outputted review and assessment of the data, Step 3: After...
If you use Claude for anything agentic such as MCP workflows, long coding sessions, file operations on the claude.ai chat then you have probably seen this: "Claude reached its tool-use limit for th...
AgentStack is a production-grade multi-agent framework built on Mastra, delivering 50+ enterprise tools, 25+ specialized agents, and A2A/MCP orchestration for scalable AI systems. Focuses on financ...
A proof-of-concept where two Claude Code instances coordinate work autonomously by sending messages to each other through Discord using a timer-based polling protocol. Each instance has a defined role and polls for instructions at regular intervals. Demonstrates cheap multi-agent coordination using existing chat infrastructure.
A multi-agent orchestration system built with Claude Code in Elixir featuring a real-time dashboard, DAG-based workflows, gossip mode for agent communication, and fault recovery. Uses Elixir's OTP supervision trees for robust agent lifecycle management. Includes parallel task execution with dependency tracking.
An AI research partner that autonomously determines what to measure and how to test hypotheses, built on Karpathy's autoresearch pattern. Features a live dashboard showing experiment progress and actionable results. Runs overnight loops to iterate on research questions without human involvement.
A Claude Code plugin that deploys multiple agents to hunt for correctness bugs — the kind that break production while all dashboards show green. Agents probe edge cases, race conditions, and integration boundaries that unit tests typically miss. Designed as a pre-release quality gate.
An open packaging format for distributing AI coding assistant extensions — one archive installs skills, agents, MCP servers, and hooks across any compatible tool. Aims to be the universal package standard for the Claude Code ecosystem, similar to how npm works for Node. Vendor-neutral by design.
A multi-agent framework for Claude Code centered on specification-first development with human approval gates. Agents work from formal specs and pause at key decision points for human review before proceeding. Designed for building reliable, auditable AI-generated software.
Extends the OpenSpec framework with autonomous 7-phase implementation workflows and specialized agents for each phase. Adds utility skills for AI coding assistants to follow a disciplined requirements-to-deployment pipeline. Covers planning, design, implementation, testing, documentation, review, and release.
A structured agent execution framework for software teams using a Kanban-style task queue, tmux for terminal management, and automated test gates that block agent progress on failures. Designed for teams who want control and auditability over what AI agents do. Keeps humans in the loop at key checkpoints.
A team of Claude Code sub-agents covering every phase of the Software Development Lifecycle from a security perspective: ASVS requirements, threat modeling, SAST triage, IaC review, compliance attestation, and release sign-off. Drop into any project without needing a dedicated security team. AGPL-3.0.
Uses Claude Code's /loop feature to automatically gather international AI news across 6 categories, summarize them bilingually in English and Traditional Chinese, and post a formatted digest to Slack. A working example of using /loop for scheduled autonomous content pipelines.
Captures and preserves architectural decisions made during AI-assisted coding sessions so teams can understand why code was built the way it was. Creates a searchable trail of agent decisions, trade-offs considered, and reasoning behind implementation choices. Helps onboard new team members to AI-generated codebases.
A Claude Code project that acts as an operating system for teams fully running on AI agents. Clone the repo, open Claude Code, and run /onboard to bootstrap the entire AI-native organization structure. Designed for teams where agents handle most of the operational work.
A cloud-independent, self-hosted agent orchestration platform supporting Claude, Codex, Gemini, OpenAI, Ollama, and four more backends with no vendor lock-in. Features a 141-node visual workflow engine, multi-agent Phase Loops, human-in-the-loop gates, and AES-256-GCM secret vault.
A CLI tool that automates creating fully isolated agent development environments by combining Docker containers, git worktrees, and Zellij terminal sessions. Run multiple parallel Claude Code agents on the same codebase without conflicts. Simple one-command setup for each workspace.
A Spec-Driven Development (SDD) toolkit that integrates with Claude Code to enforce structured design-before-code workflows. Supports multiple programming languages and guides the agent through a requirements-to-implementation pipeline. Helps reduce hallucinations and improve architectural consistency.
super-ralph is a framework for automating autonomous AI development using a tested loop and disciplined coding methods designed to produce reliable, production-ready applications. Inspired by the Ralph Loop pattern for maintaining code quality in extended autonomous sessions.
A breakdown of a comprehensive Claude Code development workflow covering agents, git worktrees, slash commands, hooks, MCP integrations, memory files, and prompt structure. Full setup documented in a blog post for developers looking to maximize their Claude Code productivity.
A Claude Code workflow pattern where Opus acts as the high-level orchestrator while aggressively delegating execution tasks to Sonnet and Haiku subagents via the Task tool. This pattern improves both token efficiency and time efficiency — Opus stays focused on direction and context while subagents handle all implementation work.
A setup combining OpenClaw and the Workstation open-source project for full mobile control of Claude Code sessions via Telegram or WhatsApp. Supports plan approval, Q&A, session creation, interruption, and screenshots from your phone. The video demonstrates a full plan-review-to-approval flow from a Telegram chat.
devpace is a BizDevOps rhythm manager for Claude Code providing 18 skills that trace business goals through requirements and code changes. Helps teams maintain alignment between business objectives and technical implementation within Claude Code sessions.
A pattern for exposing business REST APIs as CLI tools for Claude Code without placing API keys on the local machine. A Go proxy on Cloud Run injects real credentials from Secret Manager while issuing short-lived GCP identity tokens to Restish CLI. Claude Code calls the CLI via bash — no MCP server, no custom SDK needed. Processed 5 support tickets in 2 minutes as a live example.
solutions-architecture-agent orchestrates specialized skills through the complete solutions architecture lifecycle: ideation, requirements, architecture design, team composition, and cost estimation. Designed for Claude Code CLI locally and Anthropic cloud deployment.
Meta is a development workflow engine for Claude Code with a structured 5-phase cycle: Plan, Implement, Recap, Improve, and Close. It spawns autonomous git agents and manages worker processes via tmux, enabling persistent, structured development sessions with clear phase transitions and autonomous execution.
A modified Anthropic devcontainer setup that lets you run claude --dangerously-skip-permissions safely using a mitmproxy sidecar. The proxy strips Claude's real auth tokens in-flight and replaces them with dummy ones, so Claude cannot use valid credentials even in fully autonomous mode. Enables unattended sessions without exposing API keys inside the container.
AGR (Artificial General Research) is a Claude Code skill that creates an autonomous optimization loop for any measurable software problem. It uses stateless iterations via fresh Claude Code instances to prevent context degradation, variance-aware acceptance to surface micro-improvements, and a rework phase for promising-but-broken experiments. Demonstrated 46% speedup on a C++/Python library over 14 autonomous experiments.
Hey everyone. I've been running Claude Code as my daily driver and wanted it to do more. Background jobs, Slack integration, multi-agent teams, a web UI. So I built a thin gateway daemon on top of ...
Built a local-first dashboard for managing Claude Code sessions. You can run multiple AI coding agents in parallel (hive-mind), monitor them all in a live grid, and every session persists through r...
Workshop materials for Vibe Coding for Professionals — building repeatable AI workflows with Claude Code. Starter templates, completed examples, reference guide, and slides.
Plugin Claude Code — workflow de développement complet
Enforce Acceptance Test Driven Development in Claude Code to write clear specs, generate tests, and maintain consistent AI-driven testing workflows.
A workflow inside Claude Code that researches any brand from just a name and URL, generates 40 ad prompts from scratch, and automatically submits them to Nano Banana 2 for static ad creation. One input produces 40 production-ready ads — replacing what would take a creative agency days. Demonstrates Claude Code as a multi-step automation orchestrator for creative work.
A non-engineer rebuilt their Lovable website using Claude Code with Strapi headless CMS and GCP Cloud Run, creating custom skills for GCP deployment, Strapi schemas, SEO, and an automated content pipeline. Anthropic frontend skills combined with custom ones removed the constraints of the Lovable credit system. Demonstrates a full-stack migration driven entirely by Claude Code skills.
A setup guide and tooling for running Claude Code on a VPS and accessing it securely from any device. Enables persistent, cloud-based Claude Code sessions that you can pick up from a phone, tablet, or any computer. Useful for developers who want uninterrupted sessions or access to a more powerful remote machine.
A guide to using i3wm tiling window manager for efficiently running many parallel Claude Code sessions with up to 78 terminals across nine workspaces. Paired with Arch Linux and xrdp for remote access, i3wm is simpler than tmux for multi-agent setups. Also suggests letting Claude Code configure i3 and polybar via natural language.
Practical guide from months of running multiple Claude Code sessions simultaneously: assign agents to non-overlapping directories, add a shared CLAUDE.md rule telling agents to skip errors in files they did not edit, give each agent its own isolated browser profile, log all actions to a database with session IDs, and use git worktrees for shared code. A single CLAUDE.md rule eliminated 80% of cascading failure loops.
🤖 Automate development tasks with AI-driven plugins for Claude Code, boosting productivity and streamlining workflows for developers.
Multi-Agent Memory gives your AI agents a shared brain that works across machines, tools, and frameworks. Store a fact from Claude Code on your laptop, recall it from an OpenClaw agent on your serv...
My Claude Code setup after 3 months — multi-model orchestration, custom AI OS layer, and 22 agent teams [Discussion] Been using Claude Code Max plan daily for 3+ months. Started with basic usage, t...
About a week ago I posted about an autonomous agent I've been building - no OpenClaw, no other agentic frameworks, a very minimal lightweight agent ( https://github.com/hirodefi/Jork ) of course wi...
I've been spending time analyzing OpenClaw skills recently and a few recurring security patterns started showing up. Thought this community might find the technical side interesting. Some of the ma...
I built a full edtech platform with 17K questions, daily AI news pipeline, and multi-platform social automation — almost entirely with Claude Code I want to share what I have been building over the...
Personal Claude Code plugins (MIRROR)
built this thing that connects Claude to Audacity through the pipe interface. you just describe what you want and it runs the actual effects. like "remove the background noise and get this ready fo...
🤖 Create and modify workflows effortlessly with ComfyUI's AI assistant, enabling natural conversations with agents like Claude and Gemini.
As I am trying to optimize my vibe coding workflow, I saw 2 emerging patterns and I am wondering which one worked best for you: claude code agent teams or agent orchestrators like ruflo and papercl...
We used Lovable for our first website. Switching to build with Claude code was an obvious game changer - felt like I got super powers. Lovable did have some advantages when we were getting started....
A collection of specialized agents, custom commands, and templates focused on understanding, analyzing, and documenting existing codebases with Claude Code. Particularly useful for onboarding agents to large unfamiliar projects.
contextdocs is a Claude Code plugin with an AGENTS-first model where the AI agent maintains its own context documentation files. Supports Codex, Copilot, Cursor, Gemini, and 3 more tools — keeping context consistent across all of them.
A development pipeline that adapts based on code risk level and requires adversarial consensus for code reviews — multiple agents critique and defend changes before they're accepted, reducing the chance of low-quality code passing review.
A CLI-first multi-model orchestrator that routes tasks intelligently across Codex, Gemini, and Claude — sending each task to the most appropriate model based on task characteristics.
A blueprint repository providing a structured methodology (RPI: Requirements, Plan, Implement), known agent error patterns, operational rules, and project templates for Claude Code projects. A starting point for professional Claude Code project setups.
sweteam orchestrates your coding agents so you don't have to — handling task distribution, coordination, and lifecycle management with minimal manual intervention.
A modular plugin system for Claude Code covering Java/Spring Boot/LangChain4J, TypeScript/NestJS/React, Python, PHP/WordPress, AWS CloudFormation, and AI patterns. Independent plugins designed for multi-CLI environments.
A portable multi-agent harness supporting .agents-based skills, workflows, and standards-aware agent teams across Antigravity, Claude Code, Codex, OpenCode, and more — enabling skills to run consistently across any compatible AI coding tool.
fleet implements a hierarchical multi-agent architecture for Claude Code: a Bridge agent governs, Officer agents specialize, and Crew agents own specific components. Brings naval fleet structure to AI development teams.
A PMM (Product Marketing Manager) content distribution engine that scrapes newsletters, stores knowledge in an Obsidian brain, and generates multi-format content using Claude Code — fully automated from source to published output.
CodeAgora implements structured multi-agent code review as a debate — agents argue for and against proposed changes, building consensus through adversarial review before code is accepted.
Wegent is an open-source AI-native operating system for defining, organizing, and running intelligent agent teams. Provides the runtime and coordination layer for complex multi-agent systems.
zcomb is a multi-agent orchestration framework for Claude Code with real-time monitoring, file-based agent coordination, and parallel agent execution — all driven by natural language prompts.
A workspace-based coding environment for running multiple Claude Code and Codex sessions in parallel with workspace isolation — each session gets its own bounded context.
A lightweight orchestrator for Claude Code sessions — provides simple coordination primitives for multi-agent workflows without the overhead of heavier orchestration frameworks.
clauderc provides a curated setup for Claude Code with best practices baked in — agents, skills, commands, and templates pre-configured for macOS, Linux, and Windows. Reduces the friction of setting up Claude Code for the first time.
A harness router for Claude Code that improves itself over time — learns from past task outcomes to route future tasks more effectively. Applies meta-learning to agent orchestration.
A Claude Code toolkit with two modes — Pickle Rick for autonomous PRD-driven coding loops and Mr. Meeseeks for relentless code review. Part of the Ralph Loop framework for agentic development.
graqle implements graph-of-agents reasoning for Claude Code — agents reason over a shared graph structure, enabling self-governing development with 13 innovations and integrated MCP. Designed for complex reasoning tasks that benefit from structured graph traversal.
A Claude Code plugin for structured multi-session development — plan features with PRD documents, checkpoint progress at key milestones, and resume seamlessly across sessions without losing context.
convoke-agents ships domain-specialized AI agent teams for complex systems — starting with Vortex, a team of 7 agents and 22 workflows for product discovery. More specialized teams are planned.
plan-build-run is a Claude Code plugin enforcing a structured 3-phase development methodology: plan, build, and run — using context-engineered agents at each phase to keep development organized and decisions documented.
A comprehensive collection turning Claude Code into a token-efficient, one-shot coding system — includes 50+ tools, 7 skills, 5 hooks, 3 agents, and 9 in-depth guides covering advanced agentic patterns. 1-click setup via npx sklls.
A tmux-native CLI for orchestrating local AI coding agent swarms. Manages agent lifecycles, distributes tasks across panes, and provides structured coordination for parallel development — all within the terminal.
vibe-remote lets you stream and control Claude Code, OpenCode, or Codex sessions from Slack, Discord, or Lark in real time — enabling remote control of coding agents from your phone or any chat client without being at your development machine.
A multi-agent system where every file belongs to exactly one agent and every agent works in its own git worktree — preventing agents from breaking each other's code. You review the plan before any code is written, then agents execute in parallel safely.
An open-source CLI for orchestrating parallel AI-assisted development using git worktrees and tmux. Each agent works in its own worktree and tmux pane, enabling safe concurrent development without merge conflicts.
Planckatron is a drop-in folder plugin for Claude Code that enables parallel AI workers across frontend, backend, fullstack, automation, libraries, and monorepos — using file assignment to prevent worker conflicts. Activate by saying "Planckatron" in your session.
ouro-loop is an autonomous AI development framework where you define boundaries (BOUND), and the agent builds, verifies, and self-heals in a loop — similar to autoresearch for software engineering. Works with Claude Code, Cursor, and Aider.
A Claude Code skill that orchestrates a 4-agent design-to-code pipeline with Constrained Generation to produce unique, premium web projects — not generic AI output. Each agent handles a specialized phase from design to deployed code.
shiplog turns your GitHub history into a structured knowledge graph for AI development — with cross-model review gates, evidence-linked issue closure, model-tier routing, and provenance signing. Works as a single Claude Code skill compatible with Codex and Cursor.
A collection of 50+ production-tested agents, skills, and CLAUDE.md templates for Claude Code and Cursor. Designed to eliminate configuration overhead — skip setup and start building immediately with battle-tested patterns.
A comprehensive Claude Code guide covering setup, CLI commands, workflows, agent configuration, skills, and advanced tips. Designed to take developers from zero to productive with Claude Code.
ai-bouncer enforces structured development workflows in Claude Code: plan-gated TDD where tests must pass before moving on, document-driven agents that follow spec files, and triple consecutive verification before marking tasks complete.
A full Claude Code orchestrator that routes tasks through Telegram for I/O, isolates agents in Docker containers, implements swarm patterns, and provides a Mission Control UI. Designed for running complex multi-agent workflows with safety boundaries.
A detailed breakdown of every prompt used to build a 200+ tool MCP server with Claude Code. Key findings: median prompt was 32 characters, most-used prompt was "push" (9x), correction rate was 2.2%. Demonstrates that effective agentic development relies on short, direct prompts.
A practical workflow where Claude Code reads Granola meeting transcripts and automatically adds any commitments made during meetings to OmniFocus via MCP. A demonstration of chaining meeting AI with task management through Claude Code.
Anthropic released a free AI learning academy covering Claude 101, Claude Code in Action, Building with the Claude API (8+ hours), Intro to MCP, Advanced MCP, Agent Skills, and Claude on AWS Bedrock and Google Vertex. All 13 courses are fully free with certification.
creating-agent-teams is a Claude Code skill set that manages multi-agent teams by analyzing tasks, selecting the right models, assigning roles, and coordinating collaboration to optimize efficiency. It provides a structured approach to spinning up and managing agent teams for complex, parallelizable development tasks within Claude Code.
A complete video tutorial covering the Claude Code power-user workflow: running multiple Claude instances simultaneously, configuring Opus 4.6 with Plan Mode, creating custom slash commands, configuring MCP integrations, setting intelligent permissions, and building feedback loops. Demonstrates all commands in practice.
A live demonstration of building a Markdown-to-video generation system using Claude Code in under an hour. The project showcases Claude Code\'s vibe-coding approach for rapid AI-assisted development, turning structured Markdown documents directly into generated video output.
A workflow where Claude Code agents run autonomously overnight, claiming tasks from a shared ledger, running tests, and committing code without any human in the loop. Agents decide what deserves their attention and hunt for work on their own, enabling continuous codebase improvement during off-hours.
A research team used Claude Code as an auxiliary tool while writing a paper, covering three use cases: generating publication-ready figures from vague instructions, migrating a search environment across two very different codebases in under an hour, and formatting 12+ pages of math proofs in LaTeX (catching an incomplete bound condition). The post also identifies where Claude Code hits its limits: debugging problems where the answer is not in the code or logs.
Chuck is a context management tool for Claude Code that injects only the CLAUDE.md rules relevant to your current work, rather than loading everything every prompt. It remembers architectural decisions across sessions, catches contradictions before they land in code, generates session handoff briefs, and scales back automatically as context fills.
An FPGA engineer shares how Claude Code replaced a dedicated software engineer for PCIe DMA driver development: writing Linux kernel drivers, SystemVerilog RTL, testbenches, and Vivado TCL automation all from Claude Code. Includes debugging both driver and FPGA sides simultaneously via SSH, an unexpectedly powerful use case outside typical web/backend work.
Saguaro runs a background code review during your Claude Code session and feeds findings back to the same agent that wrote the code — no PR, no config, no API key required. Claude autonomously identifies and fixes issues like SQL injection or missing token validation mid-session without any user input. Runs locally, open source (Apache 2.0), uses your existing Claude Code subscription.
gnap solves the coordination problem in Claude Code multi-agent setups: how does agent B know when agent A finishes? The answer is git — using just 4 JSON files and no servers. Enables chained agent execution via shared git state at github.com/farol-team/gnap.
leashd implements a Plan → Execute → Test workflow for Claude Code with a three-layer safety pipeline: sandbox isolation, YAML-based policies, and human-in-the-loop approval. It supports driving Claude Code remotely from Telegram with a full audit trail and agent-driven end-to-end testing.
A guide for running the Qwen3.5 model locally through Claude Code on a machine with 24GB RAM. Demonstrates using Claude Code as an orchestration layer for local model inference, combining Claude's tooling with open-source model capabilities.
Technical analysis of what happens to Claude Code's context window when multiple MCP servers are connected — all tool schemas from all servers are presented simultaneously as a flat list at every step. Key insight for optimizing MCP usage in token-constrained workflows.
Underutilized Claude Code feature: running 'claude mcp serve' makes Claude Code itself into an MCP server that exposes bash, file ops, and other tools to any MCP-compatible client including Cursor. Also covers Tool Search's measured improvement from 49% to 74% tool accuracy.
A TUI + CLI workflow orchestrator for Linux built for the AI era — integrates Claude, Codex, and Gemini, includes 42 bundled workflow templates, and supports shell history import. Designed for sysadmins who want to preserve and reuse one-liners with AI assistance.
A practitioner's analysis of how Claude Code gradually introduces architectural drift — inconsistent patterns, style divergence, and technical debt — and the custom structure built to detect and correct it. Applicable to any AI coding tool, not just Claude Code.
A candid assessment of Claude Code's tendency to generate tests that satisfy the test runner without actually verifying correctness. Includes a real example where a security scanner found a live private key that passing tests missed. A must-read for anyone shipping AI-generated code.
A comprehensive guide for configuring and deploying Claude CoWork (Anthropic's collaborative AI workspace) for team use. Covers authentication, shared skill libraries, permission models, and best practices for coordinating multiple users in a shared Claude environment.
Anthropic's official announcement: Claude Opus 4.6 and Sonnet 4.6 now include the full 1M token context window at standard pricing on the Claude Platform. Opus 4.6 achieves 78.3% on MRCR v2 at 1M tokens — highest among frontier models. This is now the default for Claude Code Max/Team/Enterprise users.
A modular template system for setting up Claude Code AI agents and workflows across different programming languages. Provides project-specific structure for agents, documentation, and workflow definitions, making it easy to bootstrap a well-organized Claude Code project.
An AI-native development framework that transforms Claude Code from a single-agent tool into a structured 11-specialist-agent team. Agents include roles like architect, security reviewer, test engineer, and documentation writer, with structured handoffs and parallel review.
Community discussion on r/ClaudeCode exploring whether fully agentic pipelines with automated code review can replace human review in production. Covers the current state of trust, failure modes, and what conditions make full automation viable.
A practitioner-curated playbook distilled from 186+ replies in a viral X thread started by @toddsaunders. Covers concrete techniques people are actually using to dramatically improve Claude Code output quality, with convergent strategies across experienced users.
A framework-agnostic approach to end-to-end testing designed for AI-assisted development workflows. Provides principles and patterns for validating AI-generated code at the integration level, applicable across Claude Code, Cursor, and other agents.
Discussion exploring whether Claude (the model) can be given awareness of its own context window utilization during a session. The poster has hooks, MCP servers, and custom skills configured, and wants Claude to autonomously manage context before hitting limits.
An orchestration layer for Claude Code agents providing scheduling, inter-agent messaging, and dynamic agent discovery. Designed around the principle that intelligence doesn't scale but coordination does — enables complex multi-agent workflows without a monolithic context.
Companion repository for a Chinese course on engineering Claude Code properly — turning it from a conversational tool into a designable, reusable, governable engineering system. Demonstrates real engineering workflows including system design, skill architecture, and quality control.
A detailed breakdown of a 6-component system for using Claude Code at scale: structured task management, context hygiene, explicit handoff protocols, checkpointing, role separation, and review loops. Addresses the root cause of context degradation in long sessions.
An approach where Claude Code connects to a long-running Clojure REPL process (via clojure-mcp) instead of relying on markdown files for context. The REPL acts as a live compute layer — Claude can evaluate code and maintain state across the session without context file overhead.
Spec-driven development workflow engine for Claude Code
I build and maintain Linux servers and got tired of the same cycle: something breaks, I cobble together shell commands to fix it, they work, and then I lose them to shell history. Next time the sam...
AI development team as a Claude Code plugin -- TDD workflow, security audit, and phase-boundary compaction.
TL;DR: Claude Desktop started stopping mid-task with “Claude reached its tool-use limit for this turn” . I’m using Desktop Commander MCP from the Chat tab, not the Code tab. Before this, the same o...
A collaborative memory plugin for Claude Code that captures the collaborative process as structured memos in an Obsidian vault with hybrid search. Persistent, searchable, and interconnected memory that lets Claude build on past work across sessions.
A backend developer at a large US finance company shares their production workflow: provide detailed specs + docs + internal wikis upfront, let Claude make a first pass with a working Markdown document, manually review and test, then iterate. The ongoing working MD keeps context consistent across the session.
An AI engineering framework with built-in quality gates, persistent memory, and multi-platform support. Works inside Claude Code, Cursor, Copilot, Codex, and Gemini — making it platform-agnostic for teams using multiple AI coding tools.
A programming agent that continuously learns and evolves, driven by AI Skills. The agent adapts its behavior over time based on experience, making it progressively better at tasks specific to your codebase and coding style.
A Claude Code plugin providing multi-agent engineering orchestration with four phases: Plan, Work, Review, and Audit. Uses Agent Teams where different agents handle different roles, enabling structured software development workflows with built-in review gates.
A developer with years of pre-AI SaaS experience argues that treating Claude Code as a force multiplier — not a magic wand — requires detailed feature specs. Writing precise, engineer-style specs before starting produces dramatically better outputs than vague requests like "build me an app."
BMB (Be My Butler) applies factory accident theory to AI coding — tracking near-misses to predict future failures. v0.2 adds a watchdog Analyst agent that queries a SQLite DB after every pipeline run, a Consultant with full visibility but no authority, and Context7 MCP for live docs. Open source, MIT licensed.
A project delivery system where AI agents handle the code while CodeFrame manages everything before and after — requirements, verification, and deployment. Follows a structured Think → Build → Prove → Ship pipeline, turning ideas into verified, deployed code with clear stages.
A detailed Claude workflow for non-coders using Chat + Filesystem + Cowork on the Desktop app. Nine projects each with their own directory, following a structured layout: WORKFLOW.txt (entry point), HANDOFF.txt (state snapshot), REFERENCE.txt (on-demand detail), TASKS.txt. Optimized to extend the sweet spot of Claude sessions as long as possible.
A Reddit cautionary tale where a multi-agent MCP setup for data scraping got caught in a hallucination loop, spawning paid proxy instances every 45 seconds for 14 hours and charging $3,400 to a corporate card. Essential reading on why you need hard spending limits and cost controls before letting agents near real payment credentials.
A beginner-friendly CLI tool that guides Mac users through installing and configuring development tools and AI coding aids including Claude Code. Useful for quickly bootstrapping a productive development environment without manually hunting down each tool.
A developer shipped 163k lines of code and 6,400+ tests in a single overnight session using an autonomous Claude Code workflow. The system decomposed 144 tasks, ran them in parallel across worktrees, and merged results at dawn. A showcase of what fully autonomous multi-agent Claude Code pipelines can accomplish.
A 23-year tech veteran with no prior distro experience built a complete Linux distribution using 10–15 simultaneous Claude sessions across multiple monitors. The key insight: the most valuable skill in AI-assisted development is knowing enough to recognize when Claude is wrong, not just prompting well.
cerveau.dev implements a shared MDPlanner-driven workflow protocol that works across many Claude Code projects without duplication. Selective rules, hooks, and agents are configured per project while the core protocol stays consistent. Solves the problem of maintaining coherent workflows across a large number of repos.
After shipping 6 production projects with Claude Code, a developer shares the 5 practices with the highest ROI: invest 10 minutes in CLAUDE.md per session, use phase-based prompting (plan → review → execute), run /compact before you think you need it, use hooks for deterministic automation, and use subagents for parallel workloads.
autoimprove creates a self-driving improvement loop: Claude Code repeatedly analyzes the codebase, identifies improvements, makes changes, verifies them, and repeats. Designed for background autonomous operation where you point it at a repo and let it improve continuously.
ductwork is a single Go binary that schedules AI agent tasks with skills, persistent memory, and standalone or distributed execution modes. No external dependencies required. A minimal alternative to heavy orchestration frameworks for teams that just want scheduled agent runs.
flux sits between you and your coding agents, analyzing sessions to detect gaps and inefficiencies and recommending optimizations. Tracks what went wrong, where agents diverged from intent, and how to improve prompts and workflows over time. Designed to make you objectively better every day without losing your sanity.
Forge turns a high-level plan into tracked, dependency-aware tasks that Claude Code executes step by step. Each task is aware of upstream dependencies, ensuring the agent works through a plan in the correct order without skipping prerequisites. Focused on structured schema and code generation workflows.
A community guide showing how to replicate Anthropic's paid Code Review feature ($25/PR) using your existing Claude subscription and a local agent. The setup uses a skill, a worktree, and a cron job to get the same multi-agent PR review behavior at no additional cost.
Night Watch is a CLI tool that picks up tasks from your GitHub Projects board, runs Claude Code autonomously on each task in an isolated worktree, and opens pull requests with the results while you sleep or work. It supports configurable schedules, branch strategies, and automatic cleanup. Built for developers who want to offload repetitive coding work to autonomous agents overnight.
A complete setup for automated PR reviewing using your Claude subscription: a cron job checks for new/updated PRs every 3 minutes, a shell watcher skips already-reviewed ones, and a /review-pr skill runs Claude Opus in an isolated worktree to detect what changed and generate structured feedback. Costs nothing extra beyond your subscription and outperforms one-shot prompting.
WSL2 lacks direct hardware audio, causing ALSA errors when using Claude Code voice mode. The fix involves installing the ALSA PulseAudio plugin and creating both user-level and system-wide ALSA configs to route audio through WSLg. A 3-step process that takes under 5 minutes.
A CLI tool for the Foundational AI-Context Format (.faf) that syncs project context across multiple AI coding tools. Supports init, scoring, bidirectional sync, and export to AGENTS.md, GEMINI.md, and .cursorrules — keeping your AI context consistent whether you use Claude Code, Codex, or Cursor.
A development toolkit built specifically for Claude Code that adds adversarial code reviews, persistent session memory, and quality enforcement guardrails. Helps maintain higher code standards by having Claude critique its own work before committing.
A security-focused development workflow: RepoFortify scans pushed code across 9 security dimensions, then Claude Code reads the fix plan via MCP and autonomously resolves the issues. No dashboards or reports — just push, scan, fix, repeat until the security score rises.
A minimalist but powerful terminal development setup combining Ghostty terminal, neovim editor, free supermaven autocomplete, and Claude Code in a split pane. Shared by security researcher Simone Margaritelli (@evilsocket) as their preferred workflow. A quick reference for developers optimizing their Claude Code terminal environment.
Termius is a free iPhone SSH client that lets you remotely connect to your work machine and run Claude Code from anywhere. The author uses this to keep AI agent sessions running between gym sets. A practical tip for extending Claude Code use beyond a fixed desk setup.
RalphLoop implements a fully autonomous development loop using Claude Code to handle coding, testing, pull request creation, and deployment in sequence without human intervention. Designed as an agentic CI/CD pattern for routine development tasks. Represents a practical implementation of end-to-end autonomous software delivery with Claude Code.
A production guide for running Claude Code headlessly in cron jobs. Explains proper use of --allowedTools to scope permissions to exactly what a task needs instead of --dangerously-skip-permissions, with real cron job examples for log review and GitHub issue creation. Covers --max-turns and --max-budget-usd as essential safeguards for unattended sessions.
After 5 months and 1,075 sessions shipping 12 products with Claude Code, this developer documented every failure pattern and built 9 behavioral rules, 56 slash commands, 318 skills, and 23 agents to fix them. The ruleset addresses issues like endless planning, broken code pushes, and over-engineering. All open-sourced with real-world battle-testing behind every rule.
Relying on print() statements for debugging in Claude Code is expensive — each one consumes tokens, fills context, and causes the agent to guess at patches instead of understanding state. This post introduces a debugger skill that lets Claude set breakpoints, inspect state, and step through code without flooding the context window.
Claude Code's Agent Teams feature spawns multiple independent sessions coordinating via a shared task list. One prompt split work across three teammates who each designed a different layer — Command, Agent, and Skill — all running in parallel. The post includes the full prompt and implementation repo.
ctxforge solves the repeated context ritual at every session start: role, architecture, key files. It provides multiple named profiles per project (designer/developer/reviewer), specifying key files once that persist forever. A single init command sets everything up with reusable profiles.
By pointing Claude at ~/.claude/history.jsonl — the file storing every prompt ever typed — this developer had Claude analyze 447 prompts across 13 projects over 55 days. The analysis focused not on code quality but on prompting habits, repeated mistakes, and inefficiencies.
A non-developer built a mutual review system after getting frustrated with Claude Code diverging from plans. One agent implements while another compares work against the spec before moving on. The checkpoint-based workflow dramatically reduces divergence and debugging time.
Instead of writing E2E test suites that test assumptions about user behavior, this developer replaced them with Claude literally clicking through the app on every PR, given a goal in plain English. After 6 weeks the approach catches more real failures than scripted tests.
Vibe Graphing lets you describe what you want and Claude designs the execution graph automatically — showing which agents run in what order with what dependencies. You review and approve the graph before execution, providing human-in-the-loop oversight without writing orchestration code.
architor enforces a structured architecture design process through mandatory decision gates and challenges to assumptions before Claude writes code. Each phase must pass a quality gate before proceeding, and all decisions are documented as architecture decision records.
Version 2.1.74 of Claude Code adds the autoMemoryDirectory setting, letting all projects share a single central memory directory instead of each project maintaining its own. This enables project-agnostic memory strategies and easier pruning of stale memories across the codebase.
Instead of reviewing code after the fact, this workflow uses Opus to generate a plan first, then runs 2-3 review rounds with Codex to harden it before any implementation. A sub-agent implements while a second compares work against the plan at each checkpoint, dramatically reducing debugging time.
Claude Code's planning mode spins up an 'explore' sub-agent that attempts to fetch content from URLs, but since the explore agent lacks web search tools, it refuses. Notably, this sub-agent uses Haiku (not Sonnet/Opus), revealing how Claude Code internally routes lightweight research tasks.
A one-page printable reference for Claude Code commands, shortcuts, and features — generated by Claude researching its own documentation and updated automatically each week. Covers key slash commands, CLAUDE.md patterns, hook types, and MCP basics. Useful quick-reference for daily Claude Code users.
fellowship orchestrates parallel Claude Code agents using git worktree isolation, phase gates, and strict context discipline. Each agent works in its own worktree so branches do not interfere, and phase gates ensure agents move in sync. Designed for multi-agent feature development with structured handoffs.
Samurai-inspired multi-agent system for Claude Code that uses tmux to run parallel AI tasks. Uses a Shogun to Karo to Ashigaru hierarchy for assigning and managing work across agents, inspired by feudal Japanese command structure.
A real estate broker runs their entire client workflow using Claude Code — not for software development but as an AI-powered CRM. Thousands of lines of interconnected markdown skills handle client management, follow-ups, and deal tracking.
Instead of letting Claude make assumptions, ask it to interview you with targeted questions first. This shifts the agent into clarifying mode rather than guessing mode, reducing hallucinations and improving output quality on complex tasks.
A workflow insight: structuring your project with the right auto-loaded files dramatically reduces per-prompt setup overhead. Certain CLAUDE.md files persist context across sessions and guide the AI without repetitive instructions.
ralphex extends the Ralph autonomous execution loop to support more complex AI-driven plan execution. Enables agents to carry out multi-step plans with greater autonomy and persistence.
A real-world showcase of the modern Claude Code stack: UI mockups via Google Stitch, exported to project folder, Claude Code with browser extension for live testing, GoDaddy MCP for domain name search, and Firebase deployment. A full custom web app built from scratch in under an hour.
code-addiction enforces spec-driven development—define what you want built, and AI handles the implementation. Separates problem definition from execution to maintain clarity and control when working with autonomous coding agents.
Three open-source repos distilling 2,900+ Claude Code sessions into reusable patterns. Build Bible documents 14 principles, 19 patterns, and 8 named anti-patterns with a live-update skill (/qq-bible-add). Atlas provides a KCA (Knowledge/Capability/Activity) classification model for consistent placement of hooks, skills, and references.
Guide to setting up Claude Code on an OCI Free Tier VM (24GB RAM, 4 vCPUs) accessible via Termux on Android over SSH. Eliminates the laptop dependency for production incidents. Cost is just the Claude subscription — the VM and Termux are both free.
Technique for capturing the decision-making trail from Claude Code sessions directly in commit messages. Covers "Key decisions" (including deliberate non-choices), approach rationale, and a "State for next iteration" handoff section so subsequent agent sessions pick up without re-deriving context.
Experiment giving a Claude instance Matrix/Bluesky access, five unstructured thinking sessions per day, and persistent memory files. Multiple researcher-run agents share a chat room and debate philosophical ideas. Demonstrates multi-agent emergent behavior over weeks.
Collection of 30+ specialized Claude Code agents covering the Magento 2 development lifecycle — from module scaffolding and code review to deployment automation. Designed for expert collaboration and task delegation across complex e-commerce projects.
Run dozens of parallel Claude Code agents simultaneously using tmux, unattended. Open-source multiplexer that manages session lifecycle, coordination, and output aggregation across many concurrent agent instances.
Tool for running multiple AI agent instances simultaneously to explore divergent design directions in React projects. Each agent branch explores a different implementation path, letting you compare results and pick the best outcome.
Architecture using six PPO RL agents with persona-driven reward functions that play procedurally generated D&D quests managed by a DM agent. Integrates Claude Haiku/Sonnet chain-of-thought reasoning with episodic memory retrieval. Key finding: RL improved structural tasks, LLM layer improved social tasks.
Tool for running multiple AI models in parallel within a single Claude Code session, allowing seamless switching and comparison of outputs from different models during development tasks.
Confirmed memory leak in Claude Code v2.1.72-2.1.73: ~490 MB/hour (macOS), ~980 MB/hour (Linux), up to 30 GB/hour worst case. Leak is in native ArrayBuffer allocations from undici HTTP streaming. Workarounds: set CLAUDE_CODE_DISABLE_AUTOUPDATE=1 or pin to v2.1.52.
Multi-agent orchestration layer for Claude Code designed for minimal setup. Provides easy task delegation across parallel agents with zero configuration overhead, letting you focus on defining tasks rather than wiring agent infrastructure.
Workflow pattern using persistent markdown files for planning, progress tracking, and knowledge storage across agent sessions — inspired by Manus. Agents read and update these files to maintain state between sessions without relying on conversation context.
Agent orchestration framework using story-driven workflows to enable autonomous development and continuous learning within the Synkra AIOS framework. Builds on the Ralph Wiggum loop pattern for iterative, self-directed agent operation.
When Claude Code suggests restarting to continue, request a "restart prompt" before running /exit — Claude loses all memory on restart. Asking for a handoff prompt before exiting preserves the task context for the new session.
If Claude Code fails its connectivity check on macOS when using a firewall like LuLu or Little Snitch, create a permanent Allow rule for the claude binary. This prevents the firewall from prompting and lets Claude Code pass its startup connectivity check.
A widely-read guide (789k readers) explaining how to effectively use Claude Code on very large codebases. Key insight: write a CLAUDE.md that acts as an onboarding document — project structure, naming conventions, patterns, anti-patterns, and build commands. Covers the memory system for persisting knowledge across sessions and using voice-to-text for faster context capture.
A detailed video walkthrough from a CPO at a $2.6B company showing how to use Claude Code for an entire work day. Covers the daily planning command, CLAUDE.md configuration setup, the difference between Skills, MCP, and Hooks, and why he switched from Cursor to the terminal for Claude Code.
A developer runs five parallel coding agents in a "Code Factory" using the open-source Symphony orchestrator and Linear for task management. The setup took 2-3 days to configure and now drives 100% of their team's code output. Combines Claude Code with project management tooling for high-throughput AI development.
After deploying Claude Code to a full dev team, one developer shares a candid breakdown: excellent for understanding unfamiliar codebases and finding cross-file bugs, but poor for greenfield architecture. The key insight is that AI amplifies existing developer skill rather than replacing judgment.
A practical workflow pattern gaining traction: before letting agents write any code, prompt for 10+ HTML mockups to nail the visual direction. Iterate until happy with the design, then proceed to implementation. This prevents costly rewrites, keeps agentic sessions focused, and dramatically improves output quality.
When Claude compresses its context window, spin up a secondary AI (e.g. Gemini) to read the past session log, extract the critical information, and feed it back. This lets Claude power through compressions without losing track of the task — described as caffeine for CLIs. Works with any cheap secondary model to restore continuity automatically.
A file-based message queue for coordinating communication between local AI agents, inspired by the Maildir format. Enables reliable agent-to-agent messaging without a server — the filesystem is the transport. Ideal for orchestrating multiple Claude Code subagents on a single machine.
A community discussion on production observability for Claude Agent SDK applications, featuring an OpenTelemetry-instrumented dashboard tracking token usage, error rates, request duration, cost distribution by model, and tool call patterns. Shares practical approaches for monitoring LLM calls in prod.
A practical guide to sandboxing Claude agents using Docker Compose with volume mounts, enabling full permission mode without risk. Covers mounting ~/.claude config read-only and common pitfalls like auth token expiry inside containers. Includes a reference Docker image (claudio-dev) for reproducible setups.
A community discussion on strategies for preserving project context when hitting session limits — including prompting Claude to write progress summaries before limits are reached, using subagent handoffs, and structuring memory files to minimize re-scanning tokens on resumption. Practical advice for long-running multi-session projects.
A community discussion compiling practical browser automation strategies for Claude Code, covering Playwright MCP, agent-browser CLI, Docker-based Playwright, and subagent isolation patterns. Highlights tradeoffs around token cost, reliability, and fallback handling between WebFetch and browser tools.
A comprehensive methodology for building a persistent, compounding AI partnership with Claude — covering shared memory architecture, cognitive engine design, trust-graduated autonomy, and multi-AI coordination. Includes fork-ready CLAUDE.md templates, continuity.md for temporal memory, and session protocols. Explicitly designed to keep humans thinking rather than becoming passive consumers of AI output.
A scaffolding tool that generates lean, project-specific CLAUDE.md and context files — including only essential rules and conventions rather than bloated boilerplate. Designed to improve Claude accuracy by giving focused, relevant context without overwhelming the model with noise.
Spec-driven development for Claude Code — quality-first workflow with audit cycles and model profiles
A security-first alternative to OpenClaw. Slack, Telegram, Gmail, Calendar, browser automation, RSS, n8n workflows, Claude Code /rc handoff. OWASP ASI-aligned, single-user, self-hosted.
Template-aware development workflow plugin for Claude Code.
https://preview.redd.it/eenu01u2wcog1.png?width=3456&format=png&auto=webp&s=b6410435d36e1f0aa2c1cf57fb03c1c341a21a2c I use Claude Code pretty heavily, and I’m starting to think my workflow might be...
Multi AI agent collaboration hub - unified context, memory and orchestration for Claude Code, Codex CLI and OpenClaw
If you have ever wanted to automate a process but had to either write code for it or do it manually in a rigorous way, you know the tradeoff. The automation saves you time, but building it takes ti...
Anthropic quietly shipped an updated skill creator plugin and I wanted to see what it actually does in practice, not just read the blog post. So I pointed it at one of my existing skills - a title ...
Multi-agent orchestrator for Claude Code. Spawn, coordinate and monitor AI agents in parallel — no API key required.
The engineer's meta-prompting system for Claude Code. Amplifies every step of your development workflow while keeping you in control.
Turn Claude Code into a personal AI assistant — with persistent memory, custom skills, and structured workflows.
A collection of personal AI coding assistant configurations, specialist agents, and automated workflows optimized for Python and ML open-source development.
Worktrunk is a CLI tool that manages Git worktrees specifically designed for running multiple Claude Code agents in parallel. Each agent works in its own isolated worktree, preventing conflicts. Helps orchestrate simultaneous agent workflows on the same repo.
An experimental evaluation series comparing Claude Code Agent Teams against subagents across bug-fixing, feature implementation, and architecture design tasks. Provides structured benchmarks to help decide when to use agent teams vs subagents. Useful for teams designing multi-agent workflows.
FDF is a markdown-first AI delivery framework that gives Claude Code a structured 7-phase flow: Scope, Explore, Clarify, Architect, Implement, Verify, Summarize. Designed for non-trivial software work, preventing premature implementation. Now supports Claude Code alongside Codex.
erg is a daemon that runs Claude Code autonomously driven by workflow definitions. It persists between sessions, executing tasks according to defined workflows without manual intervention. Suitable for unattended background coding tasks.
An adversarial AI bug hunter skill that works with Claude Code, Cursor, Codex CLI, GitHub Copilot CLI, and more. Uses a multi-agent pipeline to find security vulnerabilities, logic errors, and runtime bugs, then autonomously fixes them on a safe branch — without manual review loops.
lucidshark provides a unified code quality pipeline specifically designed for AI-assisted development. Coordinates linting, testing, formatting, and review steps into a single workflow that keeps AI-generated code consistent with project standards.
GAAI turns any AI coding tool into a reliable software delivery system. Drop a .gaai/ folder into a project — Discovery defines what to build, Delivery executes autonomously until criteria pass. Works with Claude Code, Codex CLI, Gemini CLI, Cursor, and more. No SDK required, just Markdown + YAML + bash.
A practical workflow demonstrating Claude Code with the Google Workspace CLI skill to analyze and clean up a Gmail inbox with thousands of emails. Shows how to use Claude Code for real productivity automation tasks beyond coding, validating results in real-time.
A step-by-step guide with screenshots for setting up a 4-pane iTerm2 layout for Claude Code, with each pane running a different role-based model (e.g. planner, coder, reviewer, tester) with colored prompts and one-command launch. Efficient multi-model workflow setup.
Cronde is a menubar app (Tauri/Rust backend, SQLite WAL) that provides durable cron scheduling for Claude Code, surviving reboots and terminal closes. Missed jobs fire once on wake (Anacron-style). Ships with a CLI and a PostToolUse hook that auto-imports CronCreate calls from Claude Code sessions.
Clausona is a CLI that manages multiple Claude Code accounts with shared plugins and settings. New: session merge/split on profile switch — carry over conversation history or start fresh. Useful for developers managing separate work/personal Claude subscriptions.
aide provides multi-agent orchestration, persistent memory, and intelligent workflows for AI coding assistants. Supports both Claude Code and OpenCode. Designed to coordinate agents across complex, long-running tasks with memory that persists between sessions.
Shipkit is a framework that provides skills, agents, and workflows specifically for shipping MVPs fast with Claude Code. Pre-configures the development process with opinionated choices about architecture, testing, and delivery to reduce decision fatigue and accelerate shipping.
A lean AI startup team template — Claude Code acts as Tech Lead while Gemini CLI agents handle specialist roles. Bootstrap a 6-agent team onto any existing repo in minutes. Designed for human-driven oversight with AI execution.
A session manager for running Claude Code, Codex CLI, Gemini CLI, Mistral, and other coding agents simultaneously via tmux and git worktrees. Enables parallel agent workflows across multiple tools without context conflicts.
Single-repo bootstrap framework to set up Claude Code, Codex, and Gemini working together with shared memory, an IM bridge, and catalog-guided MCP/skills onboarding. Standardizes multi-agent setups from day one.
Replaces chaotic AI code generation with a disciplined spec-driven development workflow. Enforces structured phases with quality gates and uses AI agents to research best practices and plan architecture before a single line of code is written.
A tool to streamline AI-driven collaboration across multiple repositories, keeping context clear and projects organized. Prevents context bleed and helps AI agents stay focused when working on large codebases split across repos.
A developer workflow system combining a CLI (system of record) and VS Code extension. Runs tasks in isolated workflows, persists analysis, plans, and decisions to your issue tracker, and surfaces assumptions, risks, and decisions in real time. Prevents AI work from becoming undocumented.
A flexible agent system that integrates quality checks into the code generation loop. Adapts to project needs through deterministic evaluation rather than relying solely on model judgment. Ensures generated code meets quality standards before acceptance.
An article arguing that AI agents perform poorly in codebases without a proper onboarding harness. Agents that research the codebase, make a plan, then write code consistently outperform cold drops. A practical framework for building a harness that gives agents context before they start.
A developer built a content idea discovery agent using Claude Code that automatically searches Reddit, X (Twitter), and YouTube to surface topic ideas. The project demonstrates using Claude Code for multi-source research automation. An early-stage but practical example of personal productivity agents built with Claude Code.
Combining Claude Code with Obsidian creates a powerful study workflow: prompt it with what you want to learn and it auto-generates structured lectures plus beginner/intermediate/advanced hands-on courses. A novel productivity pattern for self-directed learning using Claude Code as a personal tutor and course builder.
A DevOps practitioner highlights the dangerous pattern of building AI safety guardrails reactively after incidents rather than proactively — citing a case where Claude Code deleted a production database. The recommendation is to carefully scope agent permissions and capabilities before deployment. Important reading for anyone running Claude Code in production environments.
A system that scans GitHub PRs weekly, identifies content-worthy engineering work, and auto-generates blog draft posts using Claude Code. The author calls this pattern "Quasi OpenClaw." Demonstrates Claude Code's potential for automating developer content creation from existing git activity.
A multi-phase workflow orchestrator that manages tasks from planning through QA to completion without requiring code. Operates as a layered system covering planning, execution, and review phases for complex agent-driven projects.
A practical workflow for Claude Code analytics tasks when you lack direct data warehouse access. Save DDL and SQL queries as context, have Claude ask clarifying business questions, then generate SQL. Bridges the gap between AI assistance and restricted data environments.
A workflow for thorough codebase documentation using 20+ Claude Code agents in parallel, each documenting sections independently with multiple verification passes for accuracy. Demonstrates how to maximize Claude Max for documentation-heavy projects.
A minimal agent memory system built on markdown files — no database or embeddings required. Uses four categories (Profile, Procedures, Directives, Episodes) managed by a memory-manager skill, plus a SessionEnd shell hook to auto-record sessions. Total footprint is 5 markdown files and one optional plugin.
Discussion on enabling Claude Code agents to autonomously pay for API calls using x402 (HTTP 402 protocol from Coinbase), eliminating per-service API key management. Covers three implementation approaches: SKILL.md descriptors, MCP payment servers, and direct SDK integration. Community shares working setups.
Gives Claude Code agents a persistent 'body' with scheduled jobs, session management, and Telegram integration. Enables agents to run autonomously on a schedule and report back via messaging.
A Claude Code plugin enforcing Just-In-Time (JIT) execution — establishing ground truth with real tool calls before reasoning, rather than guessing. Addresses the multiplicative token cost of hallucination feedback loops. One 10-token ls command establishing reality beats 500 tokens of assumptions.
A curated collection of 129 Claude Code agents ready to drop into ~/.claude/agents/. Includes the agency-agents system (68 personality-driven agents), everything-claude-code collection, and multi-agent team workflows. Also has conversions for Cursor, OpenCode, AntiGravity, and GitHub Copilot.
A standalone loop scheduler that works with any ACP-compatible agent. Supports interval scheduling (every 5m) and cron syntax (0 9 * * *). Use cases include monitoring deploys, watching for new PRs/issues, and generating daily summaries. Works with Claude Code, Codex CLI, Gemini CLI.
An autonomous orchestration system that takes a spec and delivers merged features. Features a Sentinel supervisor, parallel git worktrees for concurrent work, developer memory across sessions, and automatic merge handling.
An autonomous agent framework with structured memory, safety hooks, and loop management — notably built by the agent that runs on it. Demonstrates self-referential agent development.
A Claude Code plugin implementing the Research-Plan-Implement (RPI) framework for disciplined software engineering. Enforces a three-phase approach: research before planning, plan before implementing.
A framework for defining teams of Claude Code agents in YAML with scoped tools, budget limits, and human approval gates connected via a DAG. Spawns real Claude Code processes, enforces token/cost/time budgets, and produces full event logs for compliance reporting. Tested with up to 14 parallel agents.
A self-hosted orchestrator for running Claude Code and OpenCode in isolated Linux workspaces. Manages skills, configs, and encrypted secrets via a git repo. Provides secure per-project isolation for autonomous agent sessions.
A task broker for Claude Code agent sessions that pre-spawns workers for instant task assignment. Supports model routing and conversation context injection to direct tasks to the right agent with the right context.
Converts a single-line objective into a step-by-step plan where each step carries its own context — no prior session needed for any coding agent to execute it cold. Solves the planning gap for autonomous agent runs.
Controlled benchmark (42 runs, Claude Sonnet 4.6, FastAPI codebase) showing that pre-filtering context from 40K to 8K relevant tokens reduced output tokens by 63% — not just input. When given noisy context, Claude generates orientation narration; clean context produces direct answers. Practical implication: context quality affects verbosity, not just cost.
A self-hosted issue tracker and cron scheduler specifically designed for Claude Code agents. CLI-first interface means agents can create, update, and close issues directly without browser automation.
A spec-driven development system solving context rot in AI coding. Works with Claude Code, OpenCode, Gemini CLI, and Codex. Features parallel subagents, atomic commits, and a live dashboard showing progress across concurrent tasks.
A methodology for preventing confident divergence in agentic codebases. MDD addresses Claude running out of context budget to honor CLAUDE.md rules. Results across 7 production codebase sections: 190 findings, 876 tests written, 30-46x time compression vs human developers, and 60% fewer rule violations vs baseline sessions.
Multi-agent orchestration for Claude Code that is 57% cheaper than Claude's native Agent Teams with 13 additional features. Coordinates agents with zero API tokens for orchestration — using file-based coordination instead of API calls.
An agentic orchestrator that plans tasks, spawns parallel coding agents, and autonomously handles CI failures, merge conflicts, and code reviews. Reduces the need for human intervention in typical development feedback loops.
A CLI and native Claude Code skill that decomposes goals into sequential tasks, executes them one at a time via Claude Code subprocess, validates results, and auto-commits. Evolved from a separate CLI tool into a native skill using Claude's built-in subagents. Includes Architect, Developer, and QA sub-agents.
A fully automated podcast pipeline using three sequential Claude Code agents: Collector (pulls from tiered sources), Editor (writes narration with recursive summarization), and Proofreader (fact-checks against sources). Outputs audio via TTS with cloned voice. Key insight: curation rules matter more than model selection.
A Claude Code plugin automating the complete development cycle: spec → plan → implement → review → clean. Features critic loops, 8 domain expert consultants, and safety guards. Zero dependencies.
A progressive framework for growing expertise with Claude Code: tab complete → chat/agent IDE → context engineering → compounding engineering → MCP and skills → harness engineering → background agents → autonomous agent teams. Useful mental model for planning your own skill progression.
An automatic memory layer that installs as Claude Code hooks. On session start it loads your cognitive profile; on each prompt it injects relevant past context; after responses it saves new knowledge. Stores semantic facts, episodic events, and procedural workflows that evolve when something fails.
Provides domain expert agents for Claude Code with persistent context, history, and institutional memory per domain. Your AI team retains what it learned about each domain across sessions.
A workflow and Claude Code custom command for systematically porting large C++ codebases to Rust. Developed while porting the kuzu graph database (200K lines, 15 crates, 2700+ tests). The command encodes lessons about what translates mechanically vs what requires human judgment.
A markdown task management framework with YAML frontmatter for AI coding agents. Git-native, zero infrastructure, works with Claude Code, Gemini CLI, OpenCode, and Codex CLI. Each task file carries its own context.
A workflow combining JIRA MCP for task management with Playwright MCP and Windows MCP for QA validation. Tasks can only be marked Done after Claude completes QA from an actual user perspective. Addresses the vibe coding QA problem and context loss across sessions.
Running Claude Code as a Kubernetes CronJob with SKILL.md files as the workflow definition layer — plain English markdown that non-technical team members can write. Steps are defined as English instructions; Claude coordinates them by writing artifacts to disk. Running in production for over a month.
A structured autonomous development loop for Claude Code: generate a PRD, build a dependency DAG, execute tasks with two-stage review gates, and verify with Iron Law checks. Combines structured planning with autonomous execution for complex multi-file projects.
An open-source agent orchestration system built around a document-centric workflow. Agents read and write structured documents as their primary communication channel, with API connections managed through a central interface.
A library for hierarchical agent orchestration, where a parent agent spawns and coordinates child subagents for parallel task execution. The metaphor (hen/chicks) reflects the natural parent-child delegation pattern.
A comprehensive Antigravity setup for full-stack TypeScript development combining Next.js, NestJS, Prisma, and Tailwind. Provides curated engineering decisions and workflow guidance to reduce boilerplate configuration.
A multi-agent orchestration framework for Claude Code built with teams in mind. Provides shared context, role assignments, and coordination primitives so groups of agents and human collaborators can work on the same codebase without stepping on each other.
A tool that generates industry-standard specification documents (PRD, SRS, Technical Design, Test Plan) usable standalone or as a linked traceability chain. Each spec can reference the others, enabling proper requirements traceability from concept to test.
A plugin that runs Claude, Codex, and Gemini in parallel with distinct roles across four phases (discover, define, develop, deliver), requiring 75% consensus before proceeding. Each model covers the others' blind spots: Claude synthesizes, Codex nails implementation, Gemini catches ecosystem risks.
A CLI wrapper that drives a structured idea-to-execution pipeline: generate a PRD, break it into plans, review, then execute — all from a single command. Works with Claude Code and other AI CLIs.
A Bash CLI orchestrator that runs AI coding tools (Claude, Codex, Gemini, Cursor) in non-interactive fan-out and multi-agent pipelines. Useful for batch automation where you want multiple models to work on tasks in parallel.
An agent development framework focused on outcomes rather than predefined steps, allowing the framework itself to adapt as agents work. Suited for exploratory or open-ended tasks where rigid pipelines fall short.
A development toolkit combining Cursor and Claude Code to boost productivity, surface code insights, accelerate debugging, and handle large codebases. Designed for developers who use both tools and want them working together.
A CLI framework that lets you compose agent stacks and compile specialized subagents tailored for Claude Code tasks. Enables modular, reusable multi-agent architectures without manual wiring.
Describes a structured 5-10 agent workflow combining sequential thinking MCP with a Socratic meta-loop: brainstorm → debate → implement → test → iterate. Includes a self-bootstrapping technique where the workflow builds itself.
A detailed discussion of setups for keeping Claude Code sessions accessible remotely — covering tmux/WSL/SSH/Tailscale combos, Discord bots, and /remote-control issues. Highlights a persistent-identity system with Obsidian vault, soul loops, and session recovery kits. Useful reference for anyone building always-on Claude Code environments.
An autonomous coding agent system that runs multiple agents in parallel git worktrees simultaneously. Offers six purpose-built modes — greenfield, feature, refactor, fix, evolve, and security — plus CLI and Web UI with approval gates for human-in-the-loop control. A comprehensive swarm orchestration platform for large codebases.
vm0 runs workflows described in natural language automatically, bridging plain-English workflow descriptions and automated execution. Complements AI coding agents by making it easy to define and trigger multi-step processes without code.
A project that displays and queries downloaded Fitbit data, with the explicit goal of writing zero lines of code by hand. Documents the workflow as a case study in fully AI-driven development. Useful reference for those exploring how far vibe-coding can go on a complete personal project.
Claude Code's 5-hour limit is a sliding window — start it before you plan to work so it resets when you need it most. A companion repo (tappress/claude-code-warmup) provides a one-click Vercel deploy to automate the pre-warming with a cron job. Simple but effective workaround for interruptions during peak work hours.
Multi-agent system for generating high-quality AI prompts. Different agents analyze requirements, create prompts, review them, and optimize the final output. Useful for systematically improving prompts used in Claude Code workflows.
Workflow setup for using Claude Code to automate academic tasks including LaTeX document preparation, R scripts, and Quarto slide creation. Practical configuration for researchers and academics wanting AI-assisted academic writing pipelines.
Open-source Bash task runner that queues Claude Code sessions for unattended execution. Each task gets its own headless session, git branch, and automatic PR. Three-layer safety model: PreToolUse hooks blocking destructive ops, CLI constraints, and explicit mission briefs baked into every prompt.
AI-driven development pipeline that takes tickets and autonomously implements them using Claude Code. Bridges project management and code execution, shipping completed work directly from ticket to commit.
Runs parallel AI agents in isolated containers to coordinate code tasks across any project. Supports multiple AI providers and integrates with git for branch-per-agent isolation. Inspired by the swarm pattern for decomposing complex tasks.
A comprehensive practical guide compiled after weeks of testing Claude prompts, Claude Code workflows, and automation systems. Covers best prompts for real work, Claude Code-specific patterns, and productivity automation. Aimed at users who want to get more out of their Claude subscription.
An experiment in using ACP (Agent Communication Protocol) to spawn Claude Code CLI sessions on demand from within a separate software engineer assistant. When the outer agent needs Opus-level reasoning without storing OAuth tokens, it delegates to a fresh Claude Code process and waits for results. Interesting pattern for multi-agent orchestration.
A concise mental model for choosing the right Claude Code feature for each job: CLAUDE.md for persistent conventions, Skills for reusable multi-step docs, MCP for live data access, Subagents for parallel research, and Hooks for automatic side effects. Clears up a common confusion about when to use each tool.
A clean four-step workflow: design a screen in Figma, connect Claude Code to Figma via MCP, prompt it to build with Tailwind and Shadcn, then auto-generate design system docs. Eliminates the handoff gap between design and implementation. 700+ likes confirms this resonates widely.
A walkthrough of a maxed-out Claude Code setup: a tailored CLAUDE.md that encodes personal workflow preferences, Figma MCP for direct UI implementation from designs, and a hook that plays a sound notification when tasks complete. Shows how layering these features together creates a substantially different experience than using Claude Code out of the box.
A practical approach to showing Claude Code what correct code means in your specific codebase — not just code that compiles, but code that matches your team's patterns, conventions, and architecture. After a year of AI-assisted PRs still feeling wrong, the author built a system that teaches Claude your style. Solves one of the most common complaints about AI code review.
Google released a Workspace CLI that gives AI coding agents structured access to Gmail, Drive, and Calendar. Integrates with Claude Code for automating administrative and communication workflows. Useful for developers managing radio promotion, email campaigns, or document pipelines alongside code.
A detailed write-up of running a 116-configuration Claude Code setup for a one-person business. Covers how skills, hooks, agents, and sub-agents are layered to create a system that handles web apps, content pipelines, and business operations. One of the most comprehensive real-world Claude Code setups documented publicly.
A set of Claude Code workflows focused on codebase analysis, strategic planning, and technical debt reduction. Provides structured approaches for making architectural decisions with AI assistance. Aimed at teams looking to use Claude Code for long-term codebase health rather than just feature development.
Claude Code Remote Control is gated by a Statsig feature flag (tengu_ccr_bridge) that returns false for macOS (darwin) and true for Linux. The misleading error says "not yet enabled for your account" but your account is fine. A Docker workaround exists: run Claude Code in a Linux container to bypass the platform gate.
A framework for accelerating AI collaboration using Claude agent swarms with message queues for brainstorming, voting, and mentorship workflows. Enables multi-agent orchestration where multiple Claude instances collaborate on complex tasks through structured communication channels.
Bun (the JS runtime) uses both CodeRabbit and Claude Code Review together: CodeRabbit enforces project conventions defined in CLAUDE.md, while Claude Code Review catches subtle bugs. Agents iterate on feedback before a human reviewer sees the PR.
Each Claude Code session spawns a separate instance of every globally configured MCP server. With multiple stacked sessions open, this can create 30+ zombie MCP server processes (e.g., Gmail MCP) consuming significant memory. Close unused Claude Code sessions to avoid process buildup.
A practical multi-model workflow using Claude Code: (1) prompt Claude to write technical specs, (2) use an MCP Gemini integration for Claude to automatically ask Gemini to cross-review those specs. Leverages different model strengths for iterative spec refinement.
A backend API for orchestrating multi-agent AI teams across software development tasks. Provides coordination primitives for assigning and managing work across agents working in parallel.
A structured development methodology with TDD workflows, quality gates, specs, and tracking that works across Claude Code, Gemini, Cursor, Copilot, and Codex. Provides discipline and structure to AI-assisted coding sessions so output is consistent and verifiable.
A Claude Code plugin that spawns parallel agent teams working in separate git worktrees, allowing independent tasks like API endpoints, UI components, and database migrations to be built simultaneously. Type /multi-swarm with a description and the plugin decomposes and parallelizes the work automatically.
A tool that creates, validates, and animates formal Z specifications from source code, and generates code from specifications. Useful for teams that want formal methods verification in their Claude Code workflow.
A set of Claude Code plugins distilled from 451 real coding sessions, focusing on context management, investigation discipline, and guarded workflows that prevent runaway changes. Battle-tested patterns for keeping long Claude sessions on track.
A Claude Code tool that routes questions to Codex and Gemini for second opinions, creating a multi-model advisory board for design and implementation decisions. Useful when you want to pressure-test an approach before committing to it.
AI Agent Orchestrator for Claude Code
Currently, PMs in my company are using Claude Code with MCP connectors for generating ideas and writing PRDs, engineers use it for discussions and generating technical plans, once everything is app...
Claude Code plugin for project-aware development pipelines — analysis cache, multi-agent workflows, and adaptive execution
A tremendous feat of documentation, this guide covers Claude Code from beginner to power user, with production-ready templates for Claude Code features, guides on agentic workflows, and a lot of gr...
A bootstrap tool that scans your existing repo and auto-generates a tailored agent harness: CLAUDE.md, ARCHITECTURE.md, lint configs with remediation-rich errors, pre-commit hooks, and CI pipeline. Inspired by OpenAI Codex team insights, it favors short navigational maps over giant instruction files. Idempotent and works with Claude Code, Codex, or Copilot.
An end-to-end pipeline that uses Claude with the RoboSystems MCP to research and analyze SEC filings, then produces video content via HeyGen, ElevenLabs, and Shotstack. Demonstrates Claude orchestrating multi-tool, multi-vendor workflows for domain-specific content automation.
A lightweight, agent-agnostic communication protocol letting AI coding agents exchange messages across machines via file-based messaging bridged over SSH. Requires no dependencies beyond Bash, making it highly portable and easy to integrate with Claude Code or other agent frameworks for distributed workflows.
Claude Code skills — 60+ workflow automation and developer tool integrations
⚙️ Explore a curated collection of plugins for Claude Code, enhancing your workflow with commands, subagents, servers, and automation hooks.