Results for “documentation”

Generates an IEEE 830 software requirements specification from raw client input through structured clarification rounds and a review gate.

Synthesizes the current conversation into a PRD and publishes it to the project issue tracker with a triage label.

Creates structured specifications before writing code to clarify requirements, surface assumptions, and define success criteria, reducing rework and miscommunication.

Extracts and formalizes domain terminology from a conversation into a consistent glossary saved to a local file.

Create a detailed, phased implementation plan with documentation discovery. Use when asked to plan a feature, task, or multi-step implementation — especially before executing with do.

Locates files by intent using semantic search, ideal for finding implementations, definitions, or documentation in medium to large repositories.

Creates and manages Product Requirements Documents (PRDs) with structured user stories, acceptance criteria, and progress tracking for feature planning.

Continues deep iteration on an existing planning document: detects explicit file-loading intent, provides status summaries, and supports on-demand in-depth exploration.

Generates an IEEE 830 software requirements specification from raw client input, guiding users through structured clarification rounds and producing a compliant document.

Synthesizes the current conversation and codebase context into a structured PRD and publishes it to the project issue tracker with a triage label.

Guides the agent through structured protocols for writing technical specifications, implementation plans, and summaries, with file naming and task directory conventions.

Discovers the core attributes of the current code repository and its projects — languages, frameworks, tooling, and where things live — and writes a concise reference section directly into the project's AGENTS.md or CLAUDE.md for other skills, agents, and hooks to consume. Use when scanning, analyzing, or detecting the project's technology stack, build tools, or repository structure. Does not create or update project documentation — use project-documentation for writing feature or system docs.

Create a comprehensive Product Requirements Document using an 8-section template covering problem, objectives, segments, value propositions, solution, and release planning.

Creates or updates a canonical founder context document capturing company, product, market, team, and fundraising facts so downstream workflows operate on concrete data.

Translates high-level ideas into detailed Epic-level Product Requirements Documents (PRDs) that serve as the single source of truth for engineering teams.

Generates a structured Product Requirements Document (PRD) for a new feature, including clarifying questions, user stories, functional requirements, and success metrics.

Configures a repository's issue tracker, triage labels, and domain documentation so engineering skills can operate correctly.

Analyzes development requirements and generates structured acceptance criteria for AEM Edge Delivery Services tasks, including task breakdowns and edge case identification.

Generate comprehensive Product Requirements Documents (PRDs) for software systems and AI-powered features, including executive summaries, user stories, technical specifications, and risk analysis.

Creates 2D drawings and 3D models of mechanical parts, generates technical documentation and manufacturing files, and supports assembly design and parametric modeling.

Stress-tests a plan against the project's domain model and documented decisions, sharpening terminology and updating DOMAIN.md and ADRs inline as decisions crystallize.

Design SDKs with APIs that feel native, error messages that guide, and experiences that reduce friction to drive adoption through exceptional developer experience.

Takes a high-level feature from an Epic and generates a detailed Product Requirements Document (PRD) in Markdown, covering goals, user stories, requirements, and acceptance criteria.

Runs a structured interview that stress-tests a plan against the project's domain model, sharpens terminology, and updates CONTEXT.md and ADRs inline as decisions are made.

Reverse-engineer any codebase into a complete Product Requirements Document (PRD). Analyzes routes, components, state management, API integrations, and user interactions to produce business-readable documentation detailed enough for engineers or AI agents to fully reconstruct every page and endpoint. Works with frontend frameworks (React, Vue, Angular, Svelte, Next.js, Nuxt), backend frameworks (NestJS, Django, Express, FastAPI), and fullstack applications. Trigger when users mention: generate PRD, reverse-engineer requirements, code to documentation, extract product specs from code, document page logic, analyze page fields and interactions, create a functional inventory, write requirements from an existing codebase, document API endpoints, or analyze backend routes.

Creates and maintains project documentation for features, systems, and components. Use when documenting how a feature, system, or component works — including writing, updating, or organizing docs. Does not scan or detect the project's technology stack — use project-discovery for repository analysis and config detection. Does not create architectural decision records — use architectural-decision-record for ADRs. Does not create or update coding standards — use coding-standard instead. Does not generate PR descriptions — use update-pr-description for that. Does not produce runbooks for operational scenarios — use runbook for that. Does not rewrite existing prose for readability — use edit-for-readability for that. Does not produce an ephemeral, understand-now overview of code or a PR — use code-overview for that.

Use when building, refactoring, or documenting Graft apps and proxies, including when asked to create a tool server, API server, dual-protocol server, or MCP-HTTP bridge. Graft's core thesis: define tools once and serve them as both HTTP REST endpoints and MCP tools from the same server, with discovery, docs, and OpenAPI generated automatically. Covers concrete actions such as defining tools and handlers, configuring authentication middleware, setting up HTTP and stdio transports, generating OpenAPI documentation, wrapping existing APIs via proxy mode, and wiring up the full CLI workflow.