By jmeagher
John's Software Factory — takes projects from idea to implementation via phased, validated workflow.
Runs the structured clarification dialogue for a new software request. Invoke when a new workflow starts and clarification_summary is not yet in memory.
Implements a single phase of the plan using TDD. Invoke with the phase identifier. Reads phase spec from implementation_plan in memory.
Produces the technical spec and phased implementation plan after clarification is confirmed. Invoke after clarification_summary is in memory.
Reviews code changes for security issues before phase commit. Invoke after phase_complete:<name> appears in memory.
Runs the validation gate for a completed implementation phase. Checks automated tests and coordinates manual validation if needed.
Software factory clarification — use when gathering requirements before planning. Runs structured Q&A to produce a confirmed clarification summary.
Software factory memory protocol — use when reading or writing factory state. Covers JSONL memory operations, well-known keys, and agent startup protocol.
Software factory OpenTelemetry tracing — use when emitting traces for factory work. Covers root trace, phase sub-traces, and bi-directional linking.
Software factory spec and planning — use when producing a technical spec and phased implementation plan after clarification is confirmed.
Software factory TDD implementation — use when implementing a phase. Enforces red-green discipline and code security standards before committing.
Executes bash commands
Hook triggers when Bash tool is used
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 claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
[!WARNING] Work in Progress — Expect Daily Breaking Changes
This plugin is under active development and is not stable. The workflow, commands, skills, and configuration are subject to change at any time — often daily. If you are using this, expect things to break. There is no guarantee of backwards compatibility between any two versions. Proceed accordingly.
An intelligent, phased workflow plugin for Claude Code that takes software projects from initial idea through complete, validated implementation. JSF enforces test-driven development discipline, security review gates, and structured human validation checkpoints — so you ship code that works and is safe.
That's it. No additional setup is required for basic use.
JSF emits OpenTelemetry spans for every Claude session and tool call, giving you APM-style visibility into what Claude is doing and how long each step takes. Traces appear in Jaeger (or any OTLP-compatible backend) with no extra configuration beyond enabling Claude Code's standard telemetry.
Enable tracing by setting these env vars before running claude:
# Required — opt in to Claude Code telemetry (enables JSF tracing hooks too)
export CLAUDE_CODE_ENABLE_TELEMETRY=1
# Point at your OTLP collector (gRPC)
export OTEL_EXPORTER_OTLP_PROTOCOL=grpc
export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317
Once set, every Claude session automatically produces:
| Span | When emitted |
|---|---|
claude.session | Root span — opened on session start, closed on stop |
claude.tool_call | One child span per tool invocation (Bash, Read, Edit, etc.) |
claude.session.stop | Session ended normally |
claude.session.subagent_stop | Sub-agent completed |
claude.session.compact | Context compaction triggered |
claude.session.notification | Notification event fired |
factory.task | Full JSF workflow run (linked to claude.session) |
factory.phase | Each implementation phase (linked to claude.session) |
All spans are sent to your OTLP collector under service.name=jsf. View them in the Jaeger UI at http://localhost:16686 — select service jsf and you'll see the full trace tree for your session.
See the Claude Code monitoring documentation for the full list of supported environment variables, multi-team tagging, and backend configuration options.
The observability/ directory contains a ready-to-run Docker Compose stack that
receives, stores, and visualises all three OTel signal types — metrics, traces,
and logs — using entirely open-source components:
| Component | Image | Purpose |
|---|---|---|
| otel-collector | otel/opentelemetry-collector-contrib:0.92.0 | Receives OTLP and fans out to backends |
| Prometheus | prom/prometheus:v2.48.0 | Metric storage and query |
| Jaeger | jaegertracing/all-in-one:1.53 | Trace storage and UI |
| Loki | grafana/loki:2.9.3 | Log storage |
| Grafana | grafana/grafana:10.2.3 | Unified dashboard (datasources pre-wired) |
Start the stack:
cd observability/
docker compose up -d
Service endpoints:
| Service | URL |
|---|---|
| Grafana | http://localhost:3000 (admin / admin) |
| Prometheus | http://localhost:9090 |
| Jaeger UI | http://localhost:16686 |
| Loki | http://localhost:3100/ready |
| OTLP gRPC | localhost:4317 |
| OTLP HTTP | localhost:4318 |
Stop and remove volumes:
docker compose down -v
Claude Code can export metrics and events to the local collector via the
standard OpenTelemetry environment variables. Set these before running claude:
# Required — opt in to telemetry
export CLAUDE_CODE_ENABLE_TELEMETRY=1
# Send both metrics and logs/events over OTLP
export OTEL_METRICS_EXPORTER=otlp
export OTEL_LOGS_EXPORTER=otlp
# Point at the local collector's gRPC endpoint
export OTEL_EXPORTER_OTLP_PROTOCOL=grpc
export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317
npx claudepluginhub jmeagher/software-factory --plugin jsfmacOS notifications, sounds, and tmux window renaming for Claude Code events (idle detection, subagent completion)
jmeagherPersonal git and workflow commands for common tasks not covered by other plugins.
jmeagherContext-Driven Development plugin that transforms Claude Code into a project management tool with structured workflow: Context → Spec & Plan → Implement
wshobsonVerification-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.
duthahoCode transformation: Dev SDLC orchestrator (code-shipping pipeline), plan, assert, audit, review, test, refactor, debug, for-sure. Hosts engineering agents.
ai-driven-devUniversal Claude Code workflow with specialized agents, skills, hooks, and output styles for any software project. Includes orchestrator, code-reviewer, debugger, docs-writer, security-auditor, refactorer, and test-architect agents.
CloudAI-XAI-powered development workflow automation - Phase-based planning, implementation orchestration, preflight code quality checks with security scanning, ship-it workflow, and development principles generator for CLAUDE.md
charlesjones-devGive soul to your workflow. 58 AI-powered skills across 17 roles — PM, Dev, Backend, Frontend, QA, UX, Data, Detect, WordPress, Release, Security, DevOps, and Core. Spec-to-ship pipeline: scaffold, implement, test, secure, deploy. Features two-phase workflow with human approval, quality-reviewer agent, token optimization, and continuous improvement via LEARN.md system.
parhumm