feat

Plan and scope new software features with requirements and acceptance criteria.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/CuongTran69/tramthientra --skill feat-cuongtran69
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: feat
Source: https://github.com/CuongTran69/tramthientra/tree/main/.augment/skills/feat
Command: npx skills add https://github.com/CuongTran69/tramthientra --skill feat-cuongtran69

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps teams and individual contributors turn vague or incomplete feature requests into a clear, scoped, and implementable plan so work can be estimated, assigned, and delivered with minimal rework. It reduces ambiguity by enforcing requirement simplification, discovery questions, and objective acceptance criteria so engineering and product align before coding begins.

Core Features & Use Cases

  • Requirement discovery & simplification: Restate requests in plain language (Feynman Echo), surface gaps, and generate targeted clarifying questions.
  • Codebase investigation & integration mapping: Identify relevant modules, integration points, and existing patterns to estimate effort and surface hidden complexity.
  • Option comparison & risk assessment: Propose multiple implementation approaches, tradeoffs, diagrams, and a recommended path with verifiable acceptance criteria.
  • Use Case: A product manager presents a high-level new feature idea; use this Skill to produce a verified spec draft, 2-3 implementation options, a complexity estimate, and a zero-fog checklist for verification.

Quick Start

Use the feat skill to explore and size a proposed feature by summarizing the requirement, listing three clarifying questions, and recommending an implementation approach.

Frequently Asked Questions about feat

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

FAQPage Schema
How do I scope a new software feature from a vague product request?

Feature scoping from vague requests requires restating requirements in plain language, generating clarifying questions, and performing codebase investigation to map integration points and surface hidden implementation complexity before development begins.

What is the best way to estimate feature implementation effort and risks?

Estimating feature implementation effort involves analyzing the codebase for existing patterns, comparing multiple architecture approaches, identifying tradeoffs, and producing verifiable acceptance criteria to assess risk and complexity objectively.

How do I turn high-level product requirements into developer-ready specifications?

Turning product requirements into developer-ready specifications involves simplifying requests through discovery questions, mapping architecture integration points, and generating a zero-fog checklist with objective acceptance criteria for engineering alignment.

Can I compare multiple implementation approaches for a proposed feature before coding?

Yes, you can compare implementation approaches by evaluating tradeoffs, generating architecture diagrams, and recommending a specific path with verifiable acceptance criteria to ensure product and engineering teams align before coding begins.

Why does feature planning fail when product and engineering teams are misaligned?

Feature planning fails without alignment because ambiguous requirements cause rework; enforcing requirement simplification, targeted clarifying questions, and objective acceptance criteria ensures engineering and product share a clear, scoped, and implementable plan.

When do I need to perform codebase investigation during feature discovery?

Codebase investigation is needed during feature discovery to identify relevant modules, map existing integration patterns, estimate development effort, and surface hidden complexity that impacts the final implementation plan and risk assessment.