By heimeshoff
Enforce DDD workflows in AI-assisted development: model bounded contexts via Socratic sessions, capture and route ideas into backlog tasks, parallelize code implementation with verification gates, and audit claims before treating research as citable knowledge.
Cross-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 modeling 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.
Fresh-eyes auditor for a researcher's just-written report. Reads the report and the original question — not the researcher's reasoning trail — and independently re-verifies the decision-critical checkable claims against primary sources via its own WebSearch/WebFetch. Emits a PASS / FAIL / SKIP verdict that determines whether `research` ships the report or re-dispatches the researcher. Has no Write or Edit tools — never edits the report, only judges it. Called by the `research` skill's post-write gate, once per report the researcher returns.
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".
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.
Answer a question about the codebase of an Agentheim-managed project — how a feature works, where something lives, what was decided and why, or whether something is built yet — by reading the project's own structure (the index, the bounded-context READMEs, the ADRs, the task boards) and verifying against the actual source. Read-only. Invoke it directly when you want a thorough, code-grounded answer that separates what's decided from what's actually implemented.
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", "let's do some modeling", "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 wants to dump an idea, bug, or feature into the backlog FAST — no conversation, no questions, no refinement. This is the quick-jot entry point: the user is offloading a thought and wants to keep moving, not think it through. Triggers on phrases like "capture this", "jot this down", "quick capture", "note for later", "dump this in the backlog", "just file it", "add this without discussing", "brain-dump", "stick this in <bc>", "log this idea", "don't ask, just record it", and on rapid-fire multi-idea lists ("three things: A, B, C"). Routes each idea to the best-fit bounded context, writes one backlog task per idea, and reports where each landed in a single line — then gets out of the way. If the user instead wants to think an idea through, refine it, or talk it over, that's `modeling`, not this. Quick-capture never asks clarifying questions and never writes to todo — captured tasks are deliberately raw and always need a later refinement pass.
Use whenever the `research` skill is about to ship a researcher's report — between the researcher's return and the report being treated as citable knowledge. Triggers internally from `research`'s post-write gate. Spawns the `research-reviewer` agent with fresh context (no exposure to the researcher's reasoning) to re-verify the report's decision-critical checkable claims against primary sources and either PASS, FAIL with re-dispatch, or label the survivors unverified. Doctrine document; the operational steps live in `research`'s flow.
Uses power tools
Uses Bash, Write, or Edit tools
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimnpx claudepluginhub heimeshoff/agentheim --plugin agentheimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
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 one deliberate exception is /dashboard, the local web-UI launcher — see Dashboard below). The orchestrator agent routes work to specialists (strategic-modeler, tactical-modeler, architect, researcher, worker). Two of those specialists are paired with a fresh-context gate that re-checks their output before it's trusted: the verifier audits a worker's code, and the research-reviewer re-verifies a researcher's factual claims against primary sources.
| 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. |
| capture | "capture this", "jot this down", "just file it", "dump this in the backlog", "brain-dump", rapid-fire multi-idea lists | One raw backlog/ task per idea, routed to the best-fit bounded context — no questions, no refinement, no conversation. The fast sibling of modeling for when you want to offload a thought and keep moving; captured tasks always get a later modeling refine pass before a worker sees them. Never writes to todo/. |
| modeling | "I have an idea", "let's model 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. The conversational counterpart to capture: a bare invocation first shows the backlog and offers to refine before capturing. |
| 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/. Every report passes through a fresh-context research-reviewer agent that re-verifies its checkable claims (versions, prices, package names, API surface) against primary sources before the report is citable. Cited by tasks and ADRs. |
Specification-driven development workflow: specify → plan → tasks → implement
Structured project planning and execution through brainstorm, spec, and build phases across three execution tiers: sequential, delegated sub-agents, and full agent teams
AI-powered cascading development framework with design document system and multi-agent collaboration. Breaks down projects into Features (Mega Plan), Features into Stories (Hybrid Ralph), with auto-generated technical design docs, dependency-driven batch execution, Git Worktree isolation, and support for multiple AI agents (Codex, Amp, Aider, etc.).
Spec-driven development for big features. When features get too big, plan mode gets too vague—leading to hallucinations during implementation. ShipSpec replaces vague plans with structured PRDs, technical designs, and ordered tasks that keep Claude grounded.
BMAD Method - Breakthrough Method for Agile AI-Driven Development
Context-driven development framework that enables structured lifecycle for software projects: Context → Spec & Plan → Implement