aped-quick

Draft quick specs and run compressed TDD cycles for small isolated changes.

2|Updated Mar 12, 2026
One-click install
npx skills add https://github.com/yabafre/aped-claude --skill aped-quick
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: aped-quick
Source: https://github.com/yabafre/aped-claude/tree/main/src/templates/skills/aped-quick
Command: npx skills add https://github.com/yabafre/aped-claude --skill aped-quick

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

APED-quick helps you complete small, isolated changes (like hotfixes or minor refactors) without running the full A→P→E→D→R pipeline, while still enforcing a disciplined spec-first workflow and explicit user validation.

Core Features & Use Cases

  • Fast-track quick specs: Drafts a time-boxed quick spec file in quick-specs, tracks lifecycle (draft → in-progress → done/abandoned), and requires user approval before implementation.
  • Compressed TDD loop: Runs a RED → GREEN → REFACTOR cycle for minimal implementation that satisfies acceptance criteria.
  • Guardrails and scope checks: Ensures the change fits quick-mode constraints (≤5 files, 1 session, no new dependencies, no new architectural patterns) and prevents bypassing enabled/disabled state.
  • Ticket/Git workflow integration: Labels work appropriately via ticket_system and git_provider, and guides PR creation patterns for supported providers.

Quick Start

Tell the APED agent to run aped-quick to make a quick fix by answering what needs to change, why it matters now, and whether it is a fix, feature, or refactor.

Frequently Asked Questions about aped-quick

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

FAQPage Schema
How do I ship a quick hotfix without running the full development pipeline?

Ship a quick hotfix by bypassing the full pipeline and using a quick-spec gate to draft, track, and approve small isolated changes within a single session. This fast-track approach enforces a compressed TDD loop and requires explicit user validation before implementation begins.

What is a quick spec and how does it work for minor code changes?

A quick spec is a time-boxed file that drafts the scope of minor changes, tracking lifecycle from draft to done or abandoned. It requires user approval before implementation, ensuring disciplined delivery of small refactors or features.

When should I use a quick spec instead of a full TDD workflow?

Use a quick spec instead of a full TDD workflow when your change fits within five or fewer files, can be finished in one session, and requires no new dependencies or architectural pattern changes. It is designed for hotfixes, quick features, and minor refactors.

Can I use a fast-track TDD workflow for changes that add new dependencies?

No, this fast-track TDD workflow explicitly prevents changes that introduce new dependencies or new architectural patterns. Guardrails enforce that work stays within quick-mode constraints to maintain scope and prevent bypassing the enabled state.

How do I integrate quick fixes into my existing git workflow and ticket system?

Integrate quick fixes by labeling work appropriately through your ticket system and git provider, then following guided PR creation patterns. The workflow ensures your isolated changes are tracked from the quick-spec draft through to the final pull request.

Does aped-quick run automated tests during the quick fix implementation?

Yes, aped-quick runs a compressed TDD loop consisting of RED, GREEN, and REFACTOR phases to ensure minimal implementation satisfies acceptance criteria. This enforces test-driven development for your isolated changes before user approval.