heimeshoff

Vision refinement skill for this team. Invoke with /brainstorm. Reads memory/project/INDEX.md to learn the active project and either loads the active vision or starts a fresh one. Leads a structured interview to co-create or update vision.md — covering problem framing, target users, value proposition, key capabilities, and success signals. Use whenever the team is starting a new initiative or pressure-testing direction.

Structured business research for this team. Invoke with /business-research. Reads memory/project/INDEX.md to learn the active project and grounds in the active vision/research artifacts. Supports two modes — (1) competitive analysis: maps the competitor landscape, features, pricing, and positioning gaps; (2) customer journey: traces the target user's path, pain points, decision triggers, and emotional states. Delegates web searches to multiple parallel specialized agents. Always produces an unopinionated research.md artifact saved to the active session folder. Use whenever market intelligence, competitor data, user journey insight, or factual grounding is needed before making a product decision.

Idea and task capture skill for this team. Invoke with /capture. Three modes — Quick (fast brain-dump with minimal friction), Deep (structured interview that extracts tasks with acceptance criteria), Refine (cleans up and re-prioritises existing tasks). Reads memory/project/INDEX.md to learn the active project, then loads vision/research/domain artifacts as grounding. Outputs to docs/tasks.md, initialising it if missing. Use whenever the team has new ideas to capture, wants to extract tasks from a conversation, or needs to groom the backlog.

Strategic DDD domain modeling skill for this team. Invoke with /domain. Reads memory/project/INDEX.md to learn the active project, then grounds in the active research.md artifact. Leads a structured conversation to co-build a domain.md following Domain-Driven Design strategic patterns — core domain identification, subdomain classification, bounded context discovery, context mapping, ubiquitous language, and key aggregates. Emits glossary proposals for accepted ubiquitous-language terms. Use whenever the team needs to translate research insights into a shared domain model before moving to feature planning.

Reconcile memory/project/INDEX.md with what is actually on disk under exercise_one/. Invoke with /reindex. Runs the deterministic scripts/reindex_memory.sh report, presents drift to the user, proposes an updated INDEX.md, and applies it only on confirm. Use whenever a skill warns about possible memory drift, after manual edits to session folders, or as a periodic sanity check.

General-purpose research skill for this team. Invoke with /research. Reads memory/project/INDEX.md to learn the active project and grounds in the active vision. Complements /business-research (which covers competitive analysis and customer journeys) by handling technical, regulatory, UX pattern, and open-ended topic research. Always produces an unopinionated research.md artifact saved to the active session folder. Use when the team needs depth on a topic that is not a competitor landscape or customer journey map.

Tactical DDD modeling skill for this team. Invoke with /tactical-ddd. Reads memory/project/INDEX.md to learn the active project, then grounds in the active domain.md. Leads a structured conversation to produce a tactical-ddd.md with ASCII entity diagrams and Mermaid class/sequence diagrams for each bounded context. After saving the artifact, appends implementation tasks surfaced during modeling to docs/tasks.md. Carries glossary proposals forward from the domain layer. Use after /domain has produced a strategic model and before /worker begins implementation.

Task execution skill for this team. Invoke with /worker. Reads memory/project/INDEX.md and docs/tasks.md, lets the user select one task, then creates an isolated git worktree to implement it. Reads decisions.md and glossary.md before implementation so chosen names and constraints stay aligned with the team's accepted language and prior commitments. One worker, one worktree, one task at a time. Marks tasks in-progress and done. Use whenever the team is ready to move a task from backlog to implementation.

Facilitate a structured feature brainstorming session for the personal finance app. Use this skill when the user wants to explore a new feature idea, plan what to build next, or think through a product direction. Triggers on phrases like "brainstorm", "let's think about", "what should we build", "plan a feature", or "I have an idea".

Fetch ALL pending [Feature] Asana tasks and drive them through implementation with maximum safe parallelism. Use this when the user wants to drain the entire feature backlog in one command rather than processing tasks one at a time. Triggers on "process the backlog", "drain the backlog", "build everything in Asana", or explicit /process-backlog invocation.

Drive new Java feature development using red-green-refactor TDD. Use when asked to "add a feature TDD", "write the test first", "do TDD for X", or "red-green-refactor X". Takes a feature description and iterates: failing test → minimal implementation → refactor.

Build and run the team-tom Java Maven app. Use when asked to "run the app", "start the budget tracker", "demo the app", or "run java". Compiles with Maven, then launches the jar.

This skill should be used when the user or an agent asks to "implement a task", "execute a dev task", "code the task", "write the code for a task", "pick up a task from the orchestrator", or when a task file needs to be implemented. Reads a structured task specification file written by an orchestrator agent and produces working code in the target programming language.

Stage and commit the current working tree changes with a well-formed commit message. Use when the user says "commit", "git commit", "commit my changes", or invokes /git-commit.

This skill should be used when the user asks to "orchestrate tasks", "break down a feature", "plan the work", "create tasks for the developer agent", "assign tasks", "decompose the requirement", or "set up the task queue". Takes a high-level requirement, explores the codebase, breaks the work into discrete coding tasks, writes task files to .claude/tasks/, and hands them off to the dev-coder skill one at a time.

Generate or update the project vision document (vision.md) for the team's Flutter personal finance app. Use this skill whenever the user asks to create a vision doc, write up the project vision, capture "what we're building", document guiding principles, or record the team's goals and architectural rationale. Triggers on phrases like "create a vision", "write our vision", "document the vision", "vision.md", "what are we building", "capture our goals", even if they don't use the exact word "vision".

Use whenever the user wants work executed on the todo backlog — running tasks, building features, implementing what has already been modeled. Triggers on phrases like "start working", "execute the todo", "work on it", "build it", "implement the backlog", "let's go", "run the workers", "pick up where you left off", "ship what's ready". Spawns parallel worker sub-agents that resolve task dependencies and claim ready tasks from `contexts/*/todo/`. Workers follow TDD per `skills/test-driven-development/SKILL.md`. Every worker SUCCESS goes through a `verifier` agent (see `skills/verification-before-completion/SKILL.md`) before commit — failed verification re-dispatches the worker up to twice, then escalates to the user. New tasks promoted to todo during the run are picked up automatically as they become ready. Does not do modeling — only executes already-refined tasks.

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 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, Chal

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 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. Every report passes through a fresh-context `research-reviewer` agent (see `skills/research-review/SKILL.md`) that re-verifies its checkable claims against primary sources before the report is citable.

Use whenever the user wants to know what to do next on an Agentheim project — they've just finished a batch of work, they're staring at an empty board, or they're simply not sure where to put their attention. Triggers on phrases like "what's next", "what should I do now", "what now", "where do I pick up", "I'm done — now what", "what's the next sensible step", "give me a recommendation", "is there anything to work on", "what should I build next", and on the dashboard topbar "What's next" launch. Reads the vision, the per-BC task boards (backlog / todo / doing / done), the recent protocol, and the open questions, then answers in plain prose: the single next sensible step and why — or two options when the project genuinely forks. Read-only: it recommends, it never moves tasks, commits, or edits anything.

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.

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.

Implement F# backend using Giraffe + Fable.Remoting with proper separation: Validation → Domain (pure logic) → Persistence (I/O) → API. Use when implementing server-side logic, API endpoints, or business rules. Ensures validation at boundaries, pure domain functions, and proper error handling with Result types. Creates code in src/Server/ files: Validation.fs, Domain.fs, Persistence.fs, Api.fs.

Orchestrates end-to-end F# full-stack feature development following Elmish MVU + Giraffe + Fable.Remoting patterns. Use when user requests "add X feature", "implement Y", or needs guidance through complete stack implementation. Guides through: Shared types → Backend (validation/domain/persistence/API) → Frontend (state/view) → Tests. Requires project with src/Shared, src/Server, src/Client structure.

Implement F# frontend using Elmish MVU architecture with Feliz for React components. Use when creating UI, managing client state, or building interactive features with Elmish.React + Feliz. Creates state management in src/Client/State.fs (Model/Msg/update/Cmd) and UI in src/Client/View.fs. Follows strict MVU pattern with RemoteData for async operations and TailwindCSS/DaisyUI for styling.

Implement data persistence using SQLite with Dapper, JSON file storage, or event sourcing patterns. Use when adding database tables, CRUD operations, file storage, or event logs. Creates code in src/Server/Persistence.fs with patterns for queries, transactions, relationships, and async I/O. Includes SQLite schema creation, parameterized queries, and proper connection management.

Define shared domain types and API contracts for F# full-stack applications using records, discriminated unions, and Fable.Remoting interfaces. Use when starting new features, defining data structures, or creating API contracts shared between client and server. Creates types in src/Shared/Domain.fs and API interfaces in src/Shared/Api.fs. Ensures type safety across the stack with compile-time checking.

Write comprehensive tests using Expecto for F# applications including domain logic, validation, async operations, and state transitions. Use when implementing tests, ensuring code quality, or verifying functionality. Creates test files in src/Tests/ with patterns for unit tests, property tests, and async tests. Tests domain logic (pure functions), validation rules, persistence operations, and Elmish state management.

Create comprehensive validation logic for F# backends with field validators, entity validation, error accumulation, and async validation. Use when implementing input validation, complex validation rules, or need to validate API requests before processing. Creates reusable validators in src/Server/Validation.fs with patterns for required fields, length checks, email, business rules, and database checks.

Deploy F# full-stack applications with Tailscale sidecar for private network access without public ports or authentication. Use when deploying to production, setting up Docker compose with Tailscale, or need private networking setup. Creates docker-compose.yml with app + Tailscale sidecar pattern for secure private access. Includes Portainer deployment, troubleshooting, and configuration for F# Giraffe + Elmish applications.

Implement F# backend using Giraffe + Fable.Remoting with proper layer separation. Use when: "implement backend", "add API", "create endpoint", "server logic", "business rules", "backend for X", "API implementation", "server-side", "Giraffe", "Fable.Remoting". Layers: Validation → Domain (pure) → Persistence (I/O) → API. Creates code in src/Server/: Validation.fs, Domain.fs, Persistence.fs, Api.fs.

Orchestrates end-to-end F# full-stack feature development across all layers. Use when: "add feature", "implement X", "build Y", "create new feature", "full stack", "new functionality", "add capability", "implement end-to-end", "complete feature". Guides through: Shared types → Backend → Frontend → Tests. Use this for features that touch multiple layers of the application.

Implement F# frontend using Elmish MVU architecture with Feliz for React components. Use when: "add UI", "create component", "build form", "frontend", "client-side", "user interface", "view", "display", "render", "Elmish", "Feliz", "button", "input", "state management". Creates Model/Msg/update in src/Client/State.fs and views in src/Client/View.fs. Follows strict MVU pattern with RemoteData for async operations and TailwindCSS/DaisyUI for styling.

Implement data persistence using SQLite with Dapper, JSON files, or event sourcing. Use when: "database", "save data", "store", "CRUD", "create table", "query", "SQL", "SQLite", "Dapper", "file storage", "JSON file", "event sourcing", "persistence", "read from database", "write to database", "data access", "repository". Creates code in src/Server/Persistence.fs with async I/O patterns.

Implement client-side routing with Feliz.Router for F# Elmish applications. Use when: "add routing", "create pages", "navigation", "URL handling", "deep linking", "add page", "route to", "browser history", "SPA routing", "multi-page", "navigate to". Creates route definitions, URL parsing, and navigation patterns in src/Client/.

Define shared domain types and API contracts for F# full-stack applications. Use when: "define types", "create entity", "add model", "API contract", "shared types", "domain model", "record", "discriminated union", "data structure", "DTO", "interface", "type definition", "new entity", "modify types". Creates types in src/Shared/Domain.fs and API interfaces in src/Shared/Api.fs. Always start here when adding new features.

Write comprehensive tests using Expecto for F# applications. Use when: "add tests", "write tests", "test X", "unit test", "testing", "verify", "Expecto", "test coverage", "TDD", "property test", "async test", "test case". Creates tests in src/Tests/ for domain logic, validation, persistence, and state. Focus on pure functions (domain) and validation rules for best coverage.

Create validation logic for F# backends with error accumulation and async validation. Use when: "add validation", "validate X", "input validation", "complex validation", "business rules", "check email", "required fields", "async validation", "database uniqueness", "cross-field validation", "validation errors". Creates validators in src/Server/Validation.fs. Use for complex scenarios; basic validation patterns are in fsharp-backend skill.

Kill running WhisperHeim, rebuild, and launch. Use when the user says "deploy", "redeploy", "restart the app", or wants to test changes in the running application.