terraphim-engineering-skills

Phase 1 of disciplined development. Deep problem understanding before design. Use this agent when starting a new feature, refactor, or bug fix that requires understanding the problem space before jumping to solutions.

Phase 2 of disciplined development. Creates implementation plans from approved research. Use this agent after Phase 1 research is complete and approved.

Phase 3 of disciplined development. Executes approved implementation plans step by step with tests at each stage. Use this agent after design is approved.

Phase 2.5 of disciplined development. Deep specification interview after design. Use this agent to probe implementation details, edge cases, and tradeoffs through structured user interviews before implementation begins.

Phase 5 of disciplined development. Validates system against original requirements through system testing and user acceptance testing (UAT). Use this agent for final validation before production release.

Phase 4 of disciplined development. Verifies implementation against design through unit and integration testing. Use this agent after implementation to verify the code matches the specification.

Orchestrates the execution phase with quality gates: Implementation (Phase 3), Quality Evaluation, and Quality Gate review. Use this agent after planning phases are complete and approved.

Orchestrates the planning phases of the V-model: Research (Phase 1) and Design (Phase 2). Use this agent when starting a new feature or significant change that requires full disciplined planning before implementation.

Orchestrates the testing phases of the V-model: Verification (Phase 4) and Validation (Phase 5). Use this agent after implementation to verify code matches design and validate it meets user requirements.

Plan and (when feasible) implement or execute user acceptance tests (UAT) / end-to-end acceptance scenarios. Converts requirements or user stories into acceptance criteria, test cases, test data, and a sign-off checklist; suggests automation (Playwright/Cypress for web, golden/snapshot tests for CLIs/APIs). Use when validating user-visible behavior for a release, or mapping requirements to acceptance coverage.

Produce formal specifications for AI-enabled Configuration Management (CM) systems that operationalise Context Engineering principles. Use when tasked with: (1) creating CM specifications for AI-enabled programs, (2) defining semantic governance models for AI artefacts, (3) designing drift detection frameworks for prompts/models/domains, (4) specifying stage-gate control logic with semantic validation, (5) building traceability models across AI lifecycle stages, (6) defining change control for prompt and model evolution, (7) architecting AI agent roles for configuration governance, or (8) any configuration control task involving probabilistic AI behaviour, evolving prompts, shifting domain definitions, or artefact proliferation.

System architecture design for Rust/WebAssembly projects. Creates ADRs, designs APIs, plans module structures, and documents architectural decisions. Never writes implementation code - focuses purely on design and documentation.

Thorough code review for Rust/WebAssembly projects. Identifies bugs, security issues, performance problems, and maintainability concerns. Provides actionable feedback with specific suggestions.

Open source community building and engagement. Welcoming contributors, managing discussions, writing release notes, and fostering a healthy project ecosystem.

Systematic debugging for Rust applications. Root cause analysis, logging strategies, profiling, and issue reproduction. All debug changes removed before final report.

DevOps automation for Rust projects. CI/CD pipelines, container builds, deployment automation, and infrastructure as code. Optimized for GitHub Actions and Cloudflare deployment.

Phase 2 of disciplined development. Creates implementation plans based on approved research. Specifies file changes, function signatures, test strategy, and step sequence. Requires human approval before implementation.

Phase 3 of disciplined development. Executes approved implementation plans step by step. Each step includes tests, follows the design exactly, and produces reviewable commits.

Phase 1.5/2.5 of disciplined development. Evaluates document quality using the KLS (Krogstie-Lindland-Sindre) 6-dimension framework. Produces structured ratings, identifies gaps, suggests specific revisions, and blocks phase transitions when quality is below threshold. Applies to Phase 1 research docs and Phase 2 design docs.

Phase 1 of disciplined development. Deep problem understanding before design. Maps existing systems, identifies constraints, surfaces risks, and produces a research document for human approval before proceeding.

Phase 2.5 of disciplined development. Deep specification interview after design. Reads specifications, conducts thorough user interviews about implementation details, edge cases, and tradeoffs using AskUserQuestionTool. Appends refined findings to the design document. Uses convergence-based completion.

Phase 5 of disciplined development. Validates system against original requirements through system testing and user acceptance testing (UAT). Uses structured stakeholder interviews to gather sign-off and traces defects back to research or design phases.

Phase 4 of disciplined development. Verifies implementation against design through unit and integration testing. Builds traceability matrices, tracks coverage, and loops defects back to originating left-side phases.

Technical documentation for Rust projects. Creates API docs, README files, architecture guides, and contributor documentation. Follows Rust documentation conventions with strict quality standards.

Blocks destructive git and filesystem commands before execution. Prevents accidental loss of uncommitted work from git checkout --, git reset --hard, rm -rf, and similar destructive operations. Works as a Claude Code PreToolUse hook with fail-open semantics.

PageRank-powered task management using Gitea, tea CLI, and gitea-robot. Replaces beads/br and mcp_agent_mail with Gitea-native tooling. Use when agents need to pick work, prioritize issues, manage dependencies, coordinate multi-agent work, or run agile workflows against git.terraphim.cloud. Triggers: 'what should I work on', 'pick next task', 'triage issues', 'show ready tasks', 'prioritize backlog', 'claim issue', 'close issue', 'add dependency', 'show dependency graph', 'coordinate work', 'start session', 'run workflow'. Keywords: gitea, pagerank, triage, ready, robot, tea, issue, priority, dependency, backlog, sprint.

Generates Rust code for GPUI desktop UI components following Zed editor patterns. Use when building desktop applications with gpui crate, creating themed UI components, implementing autocomplete/completions, building command palettes, or working with the gpui-component library. Covers RenderOnce components, Entity state management, theming with ActiveTheme, and Zed-style UI patterns.

Production-ready code implementation following approved designs. Writes clean, tested, documented code. Zero linting violations. All code includes tests.

Evaluate agent task outputs using a three-dimension rubric (Semantic, Pragmatic, Syntactic) derived from the KLS quality framework. Use when: (1) a task has been completed and needs quality assessment before acceptance, (2) automated post-task quality checks are required, (3) multi-model consensus verdicts are needed for agent outputs, (4) documentation, code, or specification quality must be scored with structured JSON verdicts, or (5) a human fallback decision is needed after model disagreement. Produces JSONL verdict records compatible with the verdict schema in automation/judge/.

Automatic capture of failed commands as structured learning documents using Terraphim. PostToolUse hook intercepts bash command failures and records them with error context for later querying and correction. Builds an evolving knowledge base of developer mistakes and solutions to avoid repeating errors across sessions.

Leverage personal notes and documentation through Terraphim's role-based search. AI agents can search developer's local knowledge organized by domain (Rust, frontend, architecture) using the terraphim-agent REPL commands.

MD-Book documentation generator skill. Use when working with MD-Book, a modern mdbook replacement for generating HTML documentation from Markdown files. Supports syntax highlighting, live reload, Pagefind search, and Tera templates.

Open source contribution best practices. Creating quality pull requests, writing good issues, following project conventions, and collaborating effectively with maintainers.

Right-side-of-V verification/validation orchestration for a change or PR. Produces a single Quality Gate Report with evidence covering: code review, security audit, performance regression risk, requirements traceability, acceptance/UAT scenarios, and (when UI changes) visual regression testing. Use when preparing a PR for merge/release, doing a “ready?” check, or enforcing an engineering quality gate.

Log exploration and analysis using Quickwit search engine. Incident investigation, error pattern analysis, and observability workflows. Three index discovery modes for different performance and convenience trade-offs.

Create or audit requirements-to-design-to-code-to-test traceability. Builds a traceability matrix (REQ → design/ADR → implementation files → tests → evidence) and flags gaps (unimplemented requirements, untested changes, undocumented decisions). Use when you need a requirements traceability check for a PR/release, regulated/compliance work, or when requirements are drifting from implementation.

Rust-specific CI/CD pipeline patterns. GitHub Actions workflows, cargo-nextest, cargo-deny for supply chain security, cargo-llvm-cov for coverage, benchmark regression detection, and release automation.

Idiomatic Rust development with focus on safety, performance, and ergonomics. Expert in async/await, error handling, trait design, and the Rust ecosystem.

Production observability for Rust services. Structured tracing with spans, OpenTelemetry integration, Prometheus metrics export, per-request context propagation, and environment-specific log configuration.

High-performance Rust optimization. Profiling, benchmarking, SIMD, memory optimization, and zero-copy techniques. Focuses on measurable improvements with evidence-based optimization.

Security auditing for Rust/WebAssembly applications. Identifies vulnerabilities, reviews unsafe code, validates input handling, and ensures secure defaults. Follows OWASP guidelines and Rust security best practices.

Search and analyze AI coding assistant session history using Terraphim. Find past conversations, discover patterns, and learn from previous work. Supports Claude Code, Cursor, Aider, and other AI coding assistants.

Structural-semantic pull request review producing GitHub/Gitea-ready comments with severity-tiered findings (P0/P1/P2), a calibrated confidence score (1-5), a Mermaid architecture diagram, and per-file overviews. Use when reviewing a PR/MR end-to-end, posting a PR-level review comment, doing multi-round re-review after fixes, or enforcing structural conventions across language- agnostic codebases (TypeScript, Svelte/SvelteKit, Rust, Python, edge/serverless). Triggers: "review this PR", "structural review", "PR comment", "re-review", "confidence score", "PR review with diagram". Complements `code-review` (Rust-focused) and `quality-gate` (multi-skill V-model orchestration).

Knowledge graph-based text replacement using Terraphim hooks. Intercepts commands and text to apply transformations defined in the knowledge graph. Works with Claude Code PreToolUse hooks and Git prepare-commit-msg hooks.

Comprehensive test writing, execution, and failure analysis. Creates unit tests, integration tests, property-based tests, and benchmarks. Analyzes test failures and improves test coverage.

Run Ultimate Bug Scanner for automated bug detection across multiple languages. Detects 1000+ bug patterns including null pointers, security vulnerabilities, async/await issues, and resource leaks. Integrates with quality-gate workflow.

Design and implement visual regression testing for UI changes. Defines screenshot coverage, rendering stabilization, baseline management, and CI integration (e.g., Playwright screenshots, Percy/Chromatic). Use when UI/styling/layout changes need protection against regressions, or when adding screenshot-based tests to a web/WASM/desktop UI.

Secure secret management using 1Password CLI. Detect plaintext secrets in files and codebases, convert environment files to 1Password templates, inject secrets securely using op inject, and audit codebases for security compliance.

Comprehensive Caddy web server management across multiple environments. Handles multi-server operations, zero-downtime deployments, secret management with 1Password, custom builds with plugins, and systemd service management.

Xero Accounting API integration skill. Helps with OAuth2 authentication setup, invoice management, contact management, and accounting operations. Provides guidance on rate limits, token refresh, and API best practices.