claude-marketplace

Interactively elicit, capture, and maintain software/system requirements as a living, traceable repository. Use whenever the user wants to gather, write, refine, or organize requirements — including producing or updating an SRS (software/system requirements specification), writing ADRs / architecture decision records, building a requirements traceability graph (DAG), or keeping a decision ledger. Trigger proactively when the working folder already holds requirements artifacts (a `requirements/` folder of YAML, `decisions/` ADRs, an `srs.md`, or `ledger.md`), or when the user shares documents that are clearly specs, RFCs, or feature briefs and wants them structured. Also use for phrases like "let's spec this out", "interview me about what we're building", "capture these requirements", "write a decision record", or "turn these notes into a spec". Not for project management, code review, application code, dependency manifests like requirements.txt, or hardware "system requirements" (RAM/CPU).

Use this skill whenever the user wants to create a bash script that drives an autonomous coding loop — scripts that run Claude Code on a schedule (cron, GitHub Actions, systemd timer) or on-demand to make repository improvements, execute plans, triage issues, or otherwise do agentic work with minimal human intervention. Triggers include phrases like "scout script", "autonomous script", "agent harness", "script that runs on a schedule", "script that implements a plan", ".scripts/*.sh", or any request for a bash script whose body is "run Claude Code with a prompt and commit the results". Always use this skill before writing such a script — it encodes the interview flow, the adversarial-reviewer pattern, and the locking/ledger conventions.

Task structure and atomic commit patterns for granular, verifiable work units

Conflict identification and resolution patterns for requirements, decisions, and plans

Context window management techniques for maintaining efficiency and preventing context bloat

Exploration map management for tracking discussed areas and uncharted territory during DISCUSS phase

Phase coordination, agent handoffs, and workflow state machine management

Dynamic plugin enumeration and capability mapping with delegation priority and explicit routing announcements

Simplified state file management with consolidated FLOW.md (project) and ITEM-XXX.md (per-item) files

Error recognition and diagnosis patterns for infrastructure troubleshooting. Use when identifying, categorizing, or resolving errors across platforms.

Health monitoring knowledge and procedures for infrastructure platforms. Use when assessing system health, running health audits, or setting up monitoring.

Log parsing techniques and analysis methodologies for infrastructure troubleshooting. Use when retrieving, parsing, or analyzing logs from any platform.

Deep knowledge of GitHub Actions, Railway, Supabase, and Postgres platforms. Use when troubleshooting, configuring, or optimizing any of these platforms.

Brainstorming techniques for idea generation. Use when facilitating brainstorming sessions, leading ideation exercises, or helping teams generate creative solutions.

Design thinking methodology for human-centered problem solving. Use when facilitating design thinking workshops, user research sessions, or creative problem-solving activities.

Mind mapping and exploration state tracking for workshops. Use to maintain awareness of explored vs uncharted territory, implement backtracking, and ensure comprehensive coverage or documented gaps.

Core facilitation skills for running effective workshops. Use when facilitating any type of group session, managing participation, and guiding discussions.

Documentation practices for capturing workshop outputs. Use when creating session records, idea inventories, decision logs, and action item trackers.

General .NET development workflow patterns. Use when implementing features, fixing bugs, or refactoring code.

.NET build configuration and error handling. Use when building projects, diagnosing build errors, or configuring build options.

.NET test execution patterns and diagnostics. Use when running tests, analyzing test failures, or configuring test options.

.NET static analysis and code quality tools. Use when configuring analyzers, fixing warnings, or enforcing code standards.

Requirements clarification for TDD. Use BEFORE RED phase to understand WHAT to test. Asks targeted questions to uncover ambiguities, edge cases, and acceptance criteria.

Clean code principles including DRY, KISS, and YAGNI for .NET. Use when writing or reviewing code to ensure maintainability and simplicity.

SOLID design principles for .NET. Use when designing classes, interfaces, and object relationships. Ensures maintainable, testable, and extensible code.

Test-Driven Development workflow for .NET. Use when implementing features, fixing bugs, or writing new code. Guides RED-GREEN-REFACTOR cycle with proper test design.