frame-app

Decompose an application spec into a dependency-ordered DAG of testable vertical slices.

1|1|Updated Jun 27, 2026
One-click install
npx skills add https://github.com/ShortStackEngineer/loop-generator --skill frame-app-shortstackengineer
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: frame-app
Source: https://github.com/ShortStackEngineer/loop-generator/tree/main/.claude/skills/frame-app
Command: npx skills add https://github.com/ShortStackEngineer/loop-generator --skill frame-app-shortstackengineer

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve? Turning a whole multi-feature app spec into an ordered set of agent-buildable loops is error-prone: teams slice by layer instead of outcome, draw dependency edges from import graphs, and lose cross-cutting rules like authorization or audit. This Skill produces a rigorous build plan so each slice can later be turned into a RED-to-GREEN verified loop. ## Core Features & Use Cases - Outcome-based decomposition: Sorts every spec fragment into nodes (observable vertical slices), artifacts, cross-cutting concerns or shared engines, and design/manual gates, rejecting scaffold-only and layer-shaped nodes. - Dependency DAG with invariants: Draws setup-dependency needs edges (including engine-seating edges), validates acyclicity, and names both regression guards and obligation invariants that propagate as fresh RED checks on each new surface. - Frontier planning and handoff: Emits an app-plan.md (full emergent DAG plus current frontier) and promotes only verified slices into a batch manifest for downstream frame-checks and author-loop skills. - Use Case: Given a spec for a link-shortener or a multi-actor SaaS app, produce the build order — which slice is buildable now, what each slice depends on, and which invariants every later slice must re-prove. ## Quick Start Ask the agent to decompose your application spec into a dependency-ordered build plan of observable vertical slices using the frame-app skill.

Frequently Asked Questions about frame-app

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

FAQPage Schema
How do I break an app spec into buildable slices for coding agents?

Restate each requirement as an observable outcome, sort fragments into nodes, artifacts, cross-cutting concerns, and gates, then draw setup-dependency edges between outcomes. Only slices whose checks can go RED today and GREEN when built become nodes; the current buildable frontier is handed off first.

What is the difference between a vertical slice and a layer when planning a build?

A vertical slice is one observable end-to-end outcome owning its DB, API, and UI, such as a user signing up. A layer like 'build the API' has no standalone observable outcome, so it cannot be tested RED-to-GREEN and must be re-cut or routed as infrastructure.

How are cross-cutting concerns like auth and audit handled in a build plan?

They become obligation invariants, not nodes. Each downstream slice adds a fresh RED check on its own new surface, such as a 403 check per new endpoint, because a passing existing suite cannot catch an unguarded new route.

When should two outcomes be merged into one node?

Fold adjacent outcomes when they share the same needs and RED setup, such as a lifecycle chain like create-edit-share. Split them when a downstream node reads state a verb produces, or when one node accumulates axes with divergent RED setups, signaling a god-node.

Can a build plan have more than one root node?

Yes. A user-facing tier and a headless ingestion pipeline are separate walking skeletons, each seated with its own first observable outcome. They converge at the first node whose setup needs both, and the frontier may start with multiple roots.

What are the limitations of spec decomposition for agent loops?

Subjective design goals, human-workflow timings, and population-level SLOs are not falsifiable on a single build, so they become design or observer gates rather than nodes. The decomposition is also a hypothesis that downstream check-authoring may falsify, requiring re-slicing.