intent-architect
Skill0 starsChanged 3 months agoApache-2.0View on GitHub
Transform vague user requests into precise implementation contracts before development begins — clarify ambiguous goals, define scope and constraints, identify unknowns, and establish acceptance criteria. Creates an Intent Contract that prevents wasted effort from misunderstood requirements. Use when the user's request is ambiguous, underspecified, or open-ended and needs clarification before implementation begins.
In this repository49 other files it gives its agents.
- accessibility-auditorSkill
- api-doctorSkill
- browser-compatibilitySkill
- build-doctorSkill
- bundle-doctorSkill
- cache-doctorSkill
- change-cartographerSkill
- ci-cd-doctorSkill
- code-auditorSkill
- code-migratorSkill
- code-reviewerSkill
- config-doctorSkill
- container-doctorSkill
- context-keeperSkill
- contract-testerSkill
- cron-doctorSkill
- database-doctorSkill
- decision-memorySkill
- dependency-doctorSkill
- documentation-engineerSkill
- env-guardSkill
- error-boundary-doctorSkill
- feature-integritySkill
- git-hygieneSkill
- handoff-engineerSkill
- i18n-auditorSkill
- incident-debuggerSkill
- log-doctorSkill
- motion-designerSkill
- observability-engineerSkill
- performance-optimizerSkill
- product-architectSkill
- project-driftSkill
- qa-engineerSkill
- refactor-engineerSkill
- release-notesSkill
- runtime-doctorSkill
- safe-scopeSkill
- security-auditorSkill
- seo-doctorSkill
- ship-itSkill
- skill-managerSkill
- spec-doctorSkill
- state-managerSkill
- terminal-visualizerSkill
- test-engineerSkill
- type-safety-auditorSkill
- ui-redesignSkill
- ux-friction-hunterSkill
The file
We split this skill into the rules it gives an agent
5 rules. About 0 are common, 5 are distinctive, and 0 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈5
Distinctive · estimate
This author's own choices. Worth a look.
0
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 28
No success criteria: no way to know when the task is "done"
- Distinctive: line 30
If the request is already precise and unambiguous, state that and skip to implementation if asked.
- Distinctive: line 43
Do not assume. If something is ambiguous, flag it.
- Distinctive: line 47
Before creating a contract, understand the current state:
- Distinctive: line 138
If the request was already precise, output:
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Intent Architect
Creator: Neeraj Project: ClaudeSkills
Transform vague, ambiguous, or underspecified user requests into precise implementation contracts — before any code is written.
Core principle: implementation without understanding is expensive guessing. The most common source of wasted development effort is building the wrong thing. Clarifying intent first saves hours of rework.
This skill does not implement features. It produces a contract that makes implementation unambiguous.
When to activate
Activate when the user's request contains any of:
- Vague adjectives: "faster", "better", "cleaner", "modern", "nice"
- Open scope: "fix the website", "improve the app", "make it work"
- Missing constraints: no mention of budget, timeline, performance targets, or scope limits
- Multiple possible interpretations: more than one reasonable reading of the request
- No success criteria: no way to know when the task is "done"
If the request is already precise and unambiguous, state that and skip to implementation if asked.
Phase 1 — Read the request carefully
Parse the user's words exactly. Identify:
- What they asked for — the literal request.
- What they probably mean — the most likely intent.
- What they didn't say — the gaps.
- What could go wrong — misinterpretation risks.
Do not assume. If something is ambiguous, flag it.
Phase 2 — Inspect the project
Before creating a contract, understand the current state:
- What exists now? (files, components, routes, features)
- What is the technology stack?
- What are the recent changes? (git log)
- What are the constraints? (dependencies, architecture, team conventions)
This grounds the contract in reality, not imagination.
Phase 3 — Identify ambiguities
List every aspect of the request that could be interpreted in more than one way:
- Goal ambiguity — what does success look like?
- Scope ambiguity — how much of the system is involved?
- Constraint ambiguity — what must not change?
- Priority ambiguity — what matters most if trade-offs are needed?
- Technical ambiguity — which approach is intended?
For each ambiguity, state the possible interpretations.
Phase 4 — Formulate questions
For each ambiguity, write a specific question the user can answer quickly:
- Bad: "What do you want?"
- Good: "When you say 'faster', do you mean: (A) shorter initial page load, (B) faster API responses, or (C) both?"
Provide 2–3 concrete options per question when possible. Make answering easy.
Phase 5 — Create the Intent Contract
Once ambiguities are resolved (or the user provides direction), produce:
# Intent Contract
## User Goal
[One sentence: what the user wants to achieve]
## Expected Outcome
[What "done" looks like — measurable if possible]
## Scope
[What is IN scope for this task]
## Non-Goals
[What is explicitly OUT of scope]
## Constraints
[What must not change, performance budgets, compatibility requirements, etc.]
## Acceptance Criteria
- [ ] Criterion 1
- [ ] Criterion 2
- [ ] Criterion 3
## Unknowns
[Things we cannot determine without more information]
## Required Clarification
[Questions that must be answered before implementation]Phase 6 — Confirm with the user
Present the contract. Ask the user to confirm or adjust. Do not proceed to implementation until the contract is agreed upon — unless the user explicitly says to just go ahead.
What this skill does NOT do
- Does not write code.
- Does not create architecture plans (that is
product-architect). - Does not document the codebase (that is
context-keeper). - Does not audit code quality (that is
code-auditor).
This skill is a clarification and scoping tool — it sits between the user's vague request and any implementation work.
Final output
# Intent Contract
# Ambiguities Identified
# Questions Asked
# User Responses
# Confirmed ContractIf the request was already precise, output:
Request is already precise. No Intent Contract needed.
Direct implementation can proceed.Guardrails: never implement without a clear contract; never guess at user intent when you can ask; never assume scope; ground every contract in the actual project state; distinguish what the user said from what you inferred; keep contracts concise and actionable; do not produce a contract for simple, unambiguous requests; and never fabricate project constraints.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

