prompt-shaping
Propose structured interpretations of underspecified requests. Use when a user's request is vague or incomplete but reasonable assumptions can be made. Rapidly prototypes intent by restating, structuring, and committing to a next action.
When & Why to Use This Skill
The Prompt Shaping skill is a specialized framework designed to bridge the gap between vague user requests and actionable AI tasks. By restating intent, structuring components, and proposing executable 'grounding loops,' it ensures that Claude operates with high precision even when initial instructions are underspecified. This skill is essential for building reliable agentic workflows that prioritize alignment and verification over guesswork.
Use Cases
- Clarifying ambiguous technical requests: When a user asks for broad changes like 'add caching,' the skill helps the agent propose a specific implementation plan (e.g., LRU cache at the API layer) and success criteria before writing code.
- Defining 'Definition of Done' for complex tasks: It automatically generates a grounding loop that defines how the agent will verify its own work, such as writing a failing test case first to prove a bug fix is effective.
- Rapid prototyping of user intent: It allows the agent to quickly restate and structure a user's messy thoughts into a concrete next action, reducing the need for back-and-forth clarification cycles.
- Context-aware grounding: The skill prompts the agent to scan the existing environment for patterns and constraints, ensuring that proposed solutions integrate seamlessly with the current codebase or project structure.
| name | prompt-shaping |
|---|---|
| description | Propose structured interpretations of underspecified requests. Use when a user's request is vague or incomplete but reasonable assumptions can be made. Rapidly prototypes intent by restating, structuring, and committing to a next action. |
Prompt Shaping
Rapid prototyping of user intent through structured proposals.
When to Apply
User request is underspecified but agent can infer plausible intent.
Process
- Restate in natural language - Articulate what you understand the user wants, making assumptions explicit
- Bullet the structure - Break the restatement into scannable components
- Propose a grounding loop - Define how you will verify the work is complete
- State the next action - Commit to a concrete step if the interpretation is correct
Grounding Loop
Before committing to action, propose how you will verify completion:
- Define success criteria - What observable outcome proves the request is fulfilled?
- Propose a verification method - A concrete check the agent can execute (test, command, assertion)
- Commit to iteration - Run the verification repeatedly until it passes
The grounding loop ensures the agent doesn't just claim success—it demonstrates success through executable feedback.
Example proposals:
"I'll add the API endpoint, then write a test that calls it and asserts the expected response. I'll iterate until the test passes."
"I'll fix the bug by first writing a failing test that reproduces it, then modifying the code until the test passes."
"I'll refactor the module, running the existing test suite after each change to ensure no regressions."
The loop terminates when the verification passes, not when the agent believes the work is done.
Example
User: "I want to add some kind of caching"
Agent: "It sounds like you want to reduce redundant computation or network calls by storing results temporarily. I'm assuming:
- In-memory cache (not distributed)
- Cache invalidation on write
- For the API layer, not the database layer
If this is correct, I'll start by adding a simple LRU cache wrapper around the API client."
Context Grounding
Before proposing, orient to the environment:
- Scan for existing patterns that inform reasonable defaults
- Note what's present that the proposal should integrate with
- Identify constraints the user may not have stated but likely expects