claude-factory

This skill should be used when running the Claude-Factory conductor loop, understanding how cf_next_step output should be interpreted, or troubleshooting why the loop is not advancing. It explains the dispatcher pattern, how to interpret kernel step responses, and how to dispatch Claude agents vs codex GPT executors.

This skill should be used when configuring linters for a new project stack, understanding why the factory starts with the strictest linter config, or deciding whether a lint rule relaxation is justified. It explains the principle that strictness is the default and relaxation requires narrow scope and documented justification.

This skill should be used when the user or an agent is creating or reviewing an event model, understanding event modeling methodology, decomposing a workflow into slices, or learning how to use emc for event modeling. It explains the event modeling methodology as practiced in Claude-Factory — Given/When/Then scenarios, slice decomposition, transition types, and workflow composition.

This skill should be used when implementing event-sourced systems, choosing how to project state from events, designing read models, or handling performance/consistency trade-offs in event-sourced applications. It covers the eight core implementation patterns from Martin Dilger's methodology.

This skill should be used when the user or an agent is designing functions that need I/O, deciding where to put business logic, or implementing the effects pattern for requesting I/O from the functional core. It explains functional-core/imperative-shell architecture and the effects (or step/trampoline) pattern for languages that do not natively support algebraic effects.

This skill should be used when the user or an agent is designing error handling, writing functions that can fail, chaining operations that may fail, or reviewing code for error-handling correctness. It explains Scott Wlaschin's railway-oriented programming approach — using Result/Either types to make the error path explicit and composable without exceptions or defensive coding.

This skill should be used when the user or an agent is defining domain types, writing function signatures, creating data structures, or reviewing code for type safety in a Claude-Factory managed project. It explains the "semantic types everywhere" constraint — the rule that every value in the system must carry its meaning in its type, not just its structure, including values used only within a single function body.

This skill should be used when the user or an agent is building UI components, designing the design system, or understanding how UI components are organized in a Claude-Factory managed project. It explains Brad Frost's Atomic Design methodology with the Claude-Factory extension adding a 'quarks' level below atoms.

This skill should be used when the user or an agent is writing tests, reviewing tests, writing implementation code, or reviewing implementation code in a Claude-Factory managed project. It describes the enforced red-green-refactor discipline, the narrowest-change implementation rule, the recursive drill-down protocol for multi-function failures, and why behavioral tests must not couple to implementation.

This skill should be used when the user or an agent is organizing code, deciding where a new piece of functionality belongs, or reviewing code for architectural correctness in a Claude-Factory managed project. It explains the three-layer structure (platform → vertical slices → application) and the strict boundaries between slices.