tlc-spec-driven

Convert natural-language intent into traceable specifications and verified incremental tasks.

Updated Dec 20, 2023
One-click install
npx skills add https://github.com/Thiago-Cruz-eng/Hibrygame --skill tlc-spec-driven-thiago-cruz-eng
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: tlc-spec-driven
Source: https://github.com/Thiago-Cruz-eng/Hibrygame/tree/main/.claude/skills/tlc-spec-driven
Command: npx skills add https://github.com/Thiago-Cruz-eng/Hibrygame --skill tlc-spec-driven-thiago-cruz-eng

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill prevents vague, error-prone development by turning your natural-language intent into traceable specs, clear tasks, and verified execution—automatically scaling the amount of process to feature complexity.

Core Features & Use Cases

  • Adaptive planning pipeline: Specify → (Design when needed) → (Tasks when needed) → Execute, with ceremony auto-skipped for small/straightforward changes.
  • Requirement traceability: Uses traceable requirement IDs (e.g., AUTH-01) that flow from spec through tasks and validation.
  • Atomic, verifiable execution: Runs work task-by-task with explicit “Done when” verification and atomic git commits (Conventional Commits).
  • Session continuity: Supports pause/resume via handoff and persistent state (decisions, blockers, deferred ideas).
  • Stack-agnostic: Works across any coding agent and any technology stack.
  • Use case examples: Start new projects (initialize vision/roadmap), map existing codebases (brownfield analysis docs), plan and implement features (requirements/design/tasks/verification), and handle quick fixes (≤3 files).

Quick Start

Tell your agent: initialize project, map codebase, then specify feature user-authentication so it can plan requirements, break work into verified tasks, and implement with atomic commits.

Frequently Asked Questions about tlc-spec-driven

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I turn natural-language project requirements into traceable specifications?

To turn natural-language requirements into traceable specifications, the Skill converts your intent into structured specs with unique IDs (e.g., AUTH-01) that flow through design, task breakdown, and verification. It skips ceremony for small changes while maintaining full traceability for complex features.

What is the best way to plan and break down software features into verifiable tasks?

The best way to break down features into verifiable tasks is using an adaptive pipeline that generates tasks with explicit 'Done when' criteria. This ensures each task is verifiable and executed with atomic git commits, scaling the process based on feature complexity.

Does this spec-driven workflow work with any technology stack?

Yes, this spec-driven workflow is stack-agnostic and works across any coding agent and technology stack. It applies to new project initialization, brownfield codebase mapping, and feature implementation without requiring specific frameworks or platforms.

Can I pause and resume feature implementation across different coding sessions?

Yes, you can pause and resume feature implementation across sessions using the built-in session continuity support. It provides handoff capabilities and maintains persistent state, including decisions, blockers, and deferred ideas, ensuring smooth context restoration.

How do I map an existing codebase before planning new features?

To map an existing codebase before planning, the Skill performs brownfield analysis to generate mapping documentation. This allows you to understand the current architecture and seamlessly integrate new feature specifications into the existing project structure.

When should I skip the design phase during feature task breakdown?

You should skip the design phase during feature task breakdown for small or straightforward changes that affect three files or fewer. The adaptive planning pipeline automatically skips ceremony, moving directly from specification to execution for quick fixes.