Help us improve
Share bugs, ideas, or general feedback.
Share bugs, ideas, or general feedback.
Share bugs, ideas, or general feedback.
By heimeshoff
Enforces a domain-driven design workflow that starts with Socratic vision modeling to define bounded contexts, then dispatches parallel worker agents to implement tasks with TDD and automated verification before commit.
npx claudepluginhub heimeshoff/agentheim --plugin agentheimCross-cutting technical specialist. Handles decisions that span bounded contexts or involve infrastructure: persistence choice, messaging, transport, deployment topology, library choice, integration with external systems, cross-cutting concerns (auth, observability, caching, rate limiting). Called when a task's shape depends on a tech decision bigger than a single BC's implementation.
Routes modeling and execution work to the right specialist agents. Called by the model skill (for refinement and capture) and the work skill (for task execution). Takes a task or question plus project context, decides which specialist(s) to consult, runs them (in parallel when the work is independent), aggregates results, and returns refined tasks / implementation plans / ADRs.
Web research specialist. Given a question or topic, runs WebSearch and WebFetch to gather information from external sources, cross-checks claims, and produces a citation-rich markdown report in .agentheim/knowledge/research/. Called by the research skill directly, and by other specialists or skills when they need outside knowledge to proceed.
Strategic DDD specialist. Identifies bounded contexts from vision and features, names them, classifies them (core / supporting / generic), and maps their relationships. Called when a feature crosses or reshapes context boundaries, when a context map needs to be created or updated, or when the question is "what belongs where".
Tactical DDD specialist inside a single bounded context. Reasons about aggregates, entities, value objects, domain events, commands, invariants, and the workflow / lifecycle inside a BC. Called when a feature or refinement needs the inner shape of a context worked out — not where it lives (that's strategic-modeler's job).
Use whenever the user wants to start a new project, create a vision, do a Socratic modeling or discovery session, explore a problem space from scratch, or set up an initial context map and bounded contexts. Triggers on phrases like "let's brainstorm", "start a new project", "create a vision", "I want to build X", "model this out from scratch", "help me think through", "what should the shape of this be". Produces .agentheim/vision.md (and context-map.md if the domain is complex enough to warrant bounded contexts), and closes with an architecture foundation pass that unconditionally creates an `infrastructure/` BC (the standing home for globally-true tech concerns), emits decision tasks (globally-true → infrastructure BC, BC-local → originating BC), a walking-skeleton spike, and (when the vision implies frontend) a styleguide task. Deliberately produces no code — every output is markdown the user can review before `work` runs. Supports six switchable conversational modes (Interrogator [default], Suggestor, Challenger, Storyteller, Facilitator, Synthesizer) — see references/modes.md.
Use whenever the user wants to capture an idea, bug, feature request, refinement, or change to an existing bounded context — anything from "the button should be green" to "we need a whole new subscription subsystem". Also use when the user wants to refine existing backlog items or promote refined items to ready-to-work. Triggers on phrases like "I have an idea", "let's model this", "capture this", "add this to the backlog", "refine the auth backlog", "promote X to todo", "we should also", "what if we added", "there's a bug", "change the color of", "the domain needs to handle". Creates task markdown files in the appropriate bounded context with the right status, and can spawn deeper modeling sessions via the orchestrator. Supports six switchable conversational modes (Interrogator [default], Suggestor, Challenger, Storyteller, Facilitator, Synthesizer) during CAPTURE and REFINE — see references/modes.md.
Use whenever the user or another skill needs external information gathered from the web — state of the art on a topic, comparison of approaches, documentation for a library, domain knowledge from outside the codebase. Triggers on phrases like "research X", "find out about", "what's the state of the art for", "look up how others do", "compare options for", "gather info on", and also triggers internally when brainstorm or model hits an "I don't know enough" wall. Produces a research report in .agentheim/knowledge/research/ that can be referenced from tasks, ADRs, and modeling sessions.
Use whenever a worker is about to implement a task with observable behavior — features, bug fixes, refactors that should preserve behavior, any change with acceptance criteria you could turn into an assertion. Triggers internally from the `worker` agent at the start of its third action ("do the work"), and externally when the user invokes it explicitly ("do this TDD-style", "red-green-refactor this task"). Doctrine document; readable by humans and consumed by the worker as its execution discipline.
Use whenever the `work` skill is about to commit a worker's `RESULT: SUCCESS` — between the worker's return and `git add/commit`. Triggers internally from `work`'s post-success gate. Spawns the `verifier` agent with fresh context (no exposure to the worker's reasoning) to inspect the diff against the task's acceptance criteria and either PASS, FAIL with re-dispatch, or SKIP. Doctrine document; the operational steps live in `work`'s flow.
Uses power tools
Uses Bash, Write, or Edit tools
Share bugs, ideas, or general feedback.
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge.
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge.
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
Verification-first engineering toolkit for Claude Code. 15 skills across a 5-phase spine (Investigate → Design → Implement → Verify → Ship), 8 specialist agents, an interactive setup wizard. Every skill has rationalizations + evidence requirements. Built for senior ICs and tech leads.
Context-driven development framework that enables structured lifecycle for software projects: Context → Spec & Plan → Implement
Production-ready Claude Code configuration with role-based workflows (PM→Lead→Designer→Dev→QA), safety hooks, 44 commands, 19 skills, 8 agents, 43 rules, 30 hook scripts across 19 events, auto-learning pipeline, hook profiles, and multi-language coding standards
Structured project planning and execution through brainstorm, spec, and build phases across three execution tiers: sequential, delegated sub-agents, and full agent teams
Specification-driven development workflow: specify → plan → tasks → implement
HelloAGENTS — The orchestration kernel that makes any AI CLI smarter. Adds intelligent routing, quality verification (Ralph Loop), safety guards, and notifications.
A DDD-flavored agentic harness for Claude Code. Installed as a plugin once, used across projects. It turns a raw idea into a vision, a vision into a modeled backlog of bounded contexts, and a backlog into parallel, dependency-aware execution — with ADRs, a protocol log, and per-BC READMEs falling out naturally.
From inside Claude Code, in the project where you want the plugin:
/plugin marketplace add heimeshoff/agentheim
/plugin install agentheim@agentheim
The first command registers this repo as a marketplace — Claude Code clones it from GitHub for you, so no local download is needed. The owner/repo shorthand resolves to GitHub; the full https://github.com/heimeshoff/agentheim URL works too. The second command installs the plugin from the registered marketplace. Restart Claude Code afterward so hooks and skills are picked up.
When you change anything that consumer projects should pick up — a skill, an agent, a hook, a slash command — bump the version field in .claude-plugin/plugin.json and commit. Updates are only detected when the version changes: that field is the authority. Use semver: bump the patch for fixes, the minor for new behavior, the major for breaking changes to skill contracts or hook shapes.
If you'd rather not bump by hand, omit the version field entirely and Claude Code falls back to the git commit SHA — every commit then counts as a new version. The trade-off is that consumers see noise from every internal commit, not just intentional releases.
After committing and pushing to GitHub, consumers can pull the change with the steps below. Tagging the release (git tag v0.6.0 && git push --tags) is good practice so versions are pinnable.
Local/third-party marketplaces have auto-update disabled by default. To enable it, run /plugin, go to the Marketplaces tab, select agentheim, and choose "Enable auto-update". Claude Code will then refresh on startup and prompt you to run /reload-plugins when there's a new version.
To update manually:
/plugin marketplace update agentheim
/plugin update agentheim@agentheim
/reload-plugins
The first command refreshes the marketplace's view of the source repo, the second pulls the new plugin version into your project, and the third reloads skills/hooks so the change is live in the current session.
Skills auto-trigger from natural-language phrases — no slash commands to memorize. The orchestrator agent routes work to specialists (strategic-modeler, tactical-modeler, architect, researcher, worker).
| Skill | Triggered by | Produces |
|---|---|---|
| brainstorm | "let's brainstorm", "start a new project", "create a vision", "model this from scratch" | .agentheim/vision.md (+ context-map.md when warranted). Closes with an architecture foundation pass that emits type: decision tasks, a walking-skeleton spike, and (when frontend exists) a styleguide task. No code yet — those land in todo/ for work to execute. |
| model | "I have an idea", "capture this", "refine the auth backlog", "promote X to todo", "there's a bug" | Task markdown files in contexts/<bc>/backlog|todo/ with status, dependencies, acceptance criteria. |
| work | "start working", "execute the todo", "let's go", "pick up where you left off" | Code, commits, ADRs. Parallel workers respect the dependency DAG. Each worker runs TDD (red-green-refactor) by default, and every SUCCESS passes through a fresh-context verifier agent before the commit. |
| research | "research X", "state of the art for", "compare options for" | A markdown report in .agentheim/knowledge/research/. Cited by tasks and ADRs. |
The full workflow — how brainstorm, model, research, and work hand off to each other, the architecture-foundation pass, the orchestration layer, the task lifecycle, and the knowledge layer — is laid out in a visual guide:
All state for a project lives in .agentheim/ inside that project — never in the plugin dir: