tessl-test

testing tessl skills

Audit and fix agent-facing documentation. Use when CLAUDE.md may be stale, docs don't match code, or undocumented conventions exist.

Boundary-focused TDD workflow enforcing L3/L4 altitude testing, property-based tests, and phase separation. Use when implementing features that require writing tests and code.

Research phase of RPI methodology. Spawns parallel subagents for codebase exploration AND web/pattern research, then synthesizes findings for user review. Produces compact research artifact. Use at the start of non-trivial features.

Post-session reflection skill. Reads recent git history, artifacts, and context files to extract learnings and produce improvement proposals for skills, CLAUDE.md, hooks, and plan templates. Use after any substantive session.

Refactoring process with test safety. Invoke immediately when user or document mentions refactoring, or proactively when code gets too complex or messy.

Guided pair-programming mode where Claude teaches rather than writes code, ensuring engineers learn while building

Plan phase of RPI methodology. Consumes research artifact or topic and produces compact implementation plan with test specs and Agent Context blocks. Use after research or to start planning a non-trivial feature.

Implement phase of RPI methodology. Executes beads-driven task graph using isolated agents for test-first discipline. Use when executing an implementation plan from the draft skill.

Applies hexagonal (ports & adapters) architecture. Use when designing application structure, separating domain from infrastructure, creating testable boundaries, or when user mentions ports, adapters, hexagonal, or clean architecture.

Audit and fix agent-facing documentation by comparing docs to implementation, identifying broken links and stale references, surfacing undocumented conventions, and updating CLAUDE.md files. Use when CLAUDE.md may be stale, docs don't match code, or undocumented conventions exist.

Test-driven development workflow using red-green-refactor cycles with integration tests at service boundaries and property-based testing. Use when the user explicitly requests TDD, test-first development, write tests first, unit tests, red-green-refactor, or property-based testing approaches.

Explore a codebase and research external patterns before planning a new feature. Spawns parallel subagents for codebase investigation and web research, then synthesizes findings into a compact artifact (~200 lines) for user review. Use when starting a non-trivial feature, investigating unfamiliar code, or evaluating libraries and architectural approaches.

Post-session reflection skill for review session, retrospective, or session summary. Reads recent git history, artifacts, and context files to extract learnings and produce improvement proposals for skills, CLAUDE.md, hooks, and plan templates. Use after any substantive session to capture what did we learn and embed improvements back into codebase context.

Restructures code by extracting methods, renaming symbols, simplifying conditionals, removing duplication, and eliminating dead code — while running tests before and after each change to ensure behavior is preserved. Invoke immediately when user mentions refactor, refactoring, clean up, restructure, simplify, technical debt, code smell, DRY violations, or when code is messy, complex, or hard to maintain.

Guided pair-programming mode where Claude teaches rather than solves — asking guiding questions, providing hints, explaining concepts, and reviewing user-written code instead of writing solutions. Use when the user wants to learn while building: says "teach me", "help me understand", "guide me", "walk me through", "mentor me", "don't just give me the answer", "learning mode", or invokes /pair.

Transforms a research artifact or feature topic into a compact implementation plan with task breakdown, dependency mapping, test specifications, and acceptance criteria. Use when planning a non-trivial feature, designing architecture, writing a technical spec, or breaking down implementation steps before coding. Produces a phased plan with Agent Context blocks and a beads task graph for incremental execution.

Implements a feature by executing a plan phase-by-phase — writes tests first, runs them red, then implements code to make them green, then validates nothing is broken. Use when you have a plan from /draft and are ready to implement, build, develop, create, or write code for a feature using TDD.