name	project-brief-writer
description	Transform rough project ideas into problem-focused briefs that preserve learning opportunities and feed into the Skills workflow (tech-stack-advisor -> deployment-advisor -> project-spinup).

project-brief-writer

BEFORE ANY OUTPUT, VERIFY COMPLIANCE:

I will NOT suggest technologies, frameworks, or libraries — that is tech-stack-advisor's scope. I will NOT suggest deployment platforms or hosting — that is deployment-advisor's scope. I will NOT provide architecture patterns or implementation details — that is project-spinup's scope.

MY SCOPE IS LIMITED TO:

Understanding WHAT the user wants to build
Understanding WHY they want to build it
Capturing deployment INTENT (localhost vs public) — NOT platform
Recording user-stated preferences as NON-BINDING reference
Producing a NEUTRAL handoff document

If a user provides tech/platform specifics, I will:

Acknowledge without endorsing
Record in "user_stated_preferences" section (non-binding)
Redirect conversation back to WHAT and WHY

If I catch myself drifting into HOW territory, I will STOP and refocus.

Transform rough project ideas into opportunity-focused briefs through deliberate exploration. Uses a Planning Mindset approach: Discovery Protocol to understand, Framing Exercise to reflect back, and Approval Gates to ensure alignment before proceeding. Primary (machine-readable): - .docs/brief.json (structured handoff for downstream skills)

Secondary (human-readable):

.docs/PROJECT-MODE.md (workflow mode declaration)
.docs/brief-[project-name].md (narrative summary)

Contributes to:

.docs/DECISIONS.json (LOCKED decisions from this phase)

The brief captures WHAT and WHY without constraining HOW. Downstream skills receive unbiased input.

Ensure .docs/ subdirectory exists for handoff documents. 1. Check if .docs/ directory exists in current working directory 2. If not, create it 3. Proceed to mode selection Create .docs/PROJECT-MODE.md declaring learning intent before collecting any project information.

Before we start, I need to understand your learning intent for this project.

Which mode best fits your project?

LEARNING Mode (Recommended for skill development)

Want to learn about technology choices and trade-offs
Willing to explore options and understand alternatives
Timeline flexible, learning is primary goal

DELIVERY Mode (For time-constrained projects)

Need to ship quickly with minimal learning overhead
Already know technology stack or constraints
Timeline tight, speed is critical

BALANCED Mode (Flexible approach)

Want both learning AND reasonable delivery speed
Willing to explore but pragmatic about time

Your choice: [LEARNING / DELIVERY / BALANCED]

# PROJECT-MODE.md ## Workflow Declaration

Mode: [USER_CHOICE] Decision Date: [TODAY]

What This Means

[If LEARNING:]

Prioritizing understanding technology trade-offs
Subsequent skills include detailed exploration phases
Willing to spend time understanding alternatives

[If DELIVERY:]

Prioritizing speed and efficiency
Streamlined workflows with quick decisions
Minimal checkpoints

[If BALANCED:]

Want both learning and reasonable speed
Flexible pathways with optional detailed phases

Workflow Commitments

Using PROJECT-MODE.md to inform all subsequent decisions
Following appropriate checkpoint level for this mode
Mode can be changed by updating this file

Anti-Bypass Protections

Prevents "Over-Specification Problem" (detailed brief that bypasses learning).

Each skill checks this file
Checkpoint strictness based on mode
Global skipping of ALL checkpoints not allowed in LEARNING/BALANCED modes

Created .docs/PROJECT-MODE.md with MODE: [user's choice]

This file will guide the entire Skills workflow.

Understand the project through conversational exploration, not template-filling.

This phase embodies Planning Mindset: exploration before commitment, questions as conversation starters not checklists, organic flow over rigid structure.

Ask these three questions to open the conversation. Wait for responses before continuing.

Scope: "What's in scope for this project, and what's explicitly out?"
- Intent: Establish boundaries early
- Listen for: Features included, features excluded, scale expectations
Opportunity: "What becomes possible for you by building this? What will you learn or be able to do?"
- Intent: Understand the journey-focused value (not pain points)
- Listen for: Learning goals, capabilities gained, exploration interests
Curiosity Prompt: "What else should I know that I haven't asked?"
- Intent: Surface unstated context, preferences, or concerns
- Listen for: Hidden assumptions, tech preferences (record but don't endorse), deployment hints

After the initial three questions, follow-up questions emerge naturally from the conversation. Do NOT use batched triggers. Instead:

If scope is unclear, ask clarifying questions about boundaries
If opportunity is vague, probe what success would feel like (not metrics)
If curiosity prompt reveals tech preferences, acknowledge and record without endorsing
If deployment intent is mentioned, capture as category (localhost/public/TBD) only

Questions are conversation starters, not checklists. The goal is understanding, not form completion.

During discovery, mentally note (for later brief generation):

Project name/working title
Core features (WHAT it does)
Value proposition (WHY it matters to user)
Deployment intent (localhost vs public vs TBD)
Learning goals (if mentioned)
User-stated preferences (tech/platform — record verbatim, non-binding)
Out of scope items

Reflect understanding back through the user's preferred framing blend. Pause for confirmation.

Present the project through three lenses combined into a single reflection:

Solution-Centric (primary): What gets built — the tangible thing
Outcome-Centric (secondary): What it enables — without rigid success metrics
Exploration-Centric (added): What you'll learn or discover along the way

Do NOT present multiple framing options for user to choose. Use this blend as the default.

"So you're looking to build **[Solution: what gets built]** — something that lets you **[Outcome: what it enables]** and gives you a chance to **[Exploration: what you'll learn/discover]**.

Does this capture it?"

APPROVAL GATE: Wait for explicit signal before proceeding.

Prompt: "Does this capture it?"

Expected signals:

🟢 Green: "Good" / "Yes" / "Continue" / "👍" → Proceed to brief generation
🟡 Yellow: "Yes, but..." / "Almost" / "Tweak X" → Adjust framing, re-confirm
🔴 Red: "Wait" / "Back up" / "Let's rethink" → Return to discovery

NEVER proceed on silence. Always wait for explicit confirmation.

Check for and redirect any technology or platform specifics that slipped through.

If user input includes:

Programming languages, frameworks, or libraries → Record as preference, redirect to WHAT
Architecture patterns (microservices, MVC, etc.) → Note interest, keep brief neutral
Deployment platforms (AWS, Vercel, fly.io, etc.) → Record as preference, capture intent only
Infrastructure specifics (Docker, Kubernetes, etc.) → Record as preference, stay neutral

"I'll record [specific tech/platform] as a stated preference — downstream skills will see it but aren't bound by it. For the brief, I'll describe what you need without specifying the technology. Does that work?"

Build a REST API using Express.js I'll note "Express.js" as a preference. For the brief: "Build an API that allows authenticated access to data." Sound right?

Deploy to my VPS with Docker I'll capture "VPS with Docker" as your stated preference. The brief will show deployment intent as "Public" and deployment-advisor will evaluate your preference alongside alternatives.

Generate both JSON handoff (primary) and markdown summary (secondary).

Generate .docs/brief.json with this structure:

{
  "document_type": "brief",
  "version": "1.0",
  "created": "[ISO date]",
  "project": "[project-name]",
  "mode": "[LEARNING/DELIVERY/BALANCED]",

  "summary": {
    "name": "[Project Name]",
    "description": "[1-2 sentence description]",
    "deployment_intent": "[localhost/public/TBD]"
  },

  "framing": {
    "solution": "[What gets built]",
    "outcome": "[What it enables]",
    "exploration": "[What user learns/discovers]"
  },

  "scope": {
    "in_scope": [
      "[Feature/capability 1]",
      "[Feature/capability 2]"
    ],
    "out_of_scope": [
      "[Explicitly excluded item 1]",
      "[Explicitly excluded item 2]"
    ]
  },

  "learning_goals": [
    "[Learning goal 1]",
    "[Learning goal 2]"
  ],

  "decisions": [
    {
      "id": "PBW-001",
      "category": "deployment_intent",
      "decision": "[localhost/public/TBD]",
      "status": "LOCKED",
      "rationale": "[Why this intent was chosen]"
    },
    {
      "id": "PBW-002",
      "category": "scope",
      "decision": "[Key scope decision]",
      "status": "LOCKED",
      "rationale": "[Why this boundary was set]"
    }
  ],

  "user_stated_preferences": {
    "technology": ["[Tech preference if stated]"],
    "platform": ["[Platform preference if stated]"],
    "binding": false,
    "note": "These are starting points for downstream skills, not constraints"
  },

  "rationale_capture": {
    "key_decisions": [
      {
        "topic": "[Decision topic]",
        "chosen": "[What was decided]",
        "why": "[Reasoning]",
        "alternatives_considered": ["[Alternative 1]", "[Alternative 2]"],
        "reversibility": "[easy/moderate/difficult]"
      }
    ]
  },

  "handoff_to": ["tech-stack-advisor"]
}

Also generate .docs/brief-[project-name].md as human-readable summary:

[Project Name] - Project Brief

Overview

[1-2 paragraph narrative combining Solution + Outcome + Exploration framing]

What Gets Built

[Core features as narrative, technology-neutral]

Key Capabilities:

[Capability 1]
[Capability 2]
[Capability 3]

What's Out of Scope

[Excluded item 1]
[Excluded item 2]

Deployment Intent

Target: [Localhost / Public / TBD]

Learning Goals

[Learning goal 1]
[Learning goal 2]

User Stated Preferences (Non-Binding)

Technology: [Preferences or "None stated"] Platform: [Preferences or "None stated"]

These preferences are visible to downstream skills but do not constrain their recommendations.

Decisions Made

Decision	Chosen	Rationale
Deployment Intent	[choice]	[why]
[Other key decision]	[choice]	[why]

Next Steps

Invoke tech-stack-advisor to explore technology options.

Also update .docs/DECISIONS.json (create if doesn't exist):

Add entries for each LOCKED decision from this phase. These decisions become authoritative for downstream skills.

Save all outputs to .docs/ subdirectory.

1. .docs/brief.json (primary handoff — machine-readable) 2. .docs/brief-[project-name].md (secondary — human-readable summary) 3. .docs/DECISIONS.json (create or update with LOCKED decisions from this phase)

Created: - .docs/brief.json (structured handoff for downstream skills) - .docs/brief-[project-name].md (human-readable summary) - Updated .docs/DECISIONS.json with [N] locked decisions

Present completion summary and wait for explicit approval before handoff.

## Brief Complete

Project: [project-name] Mode: [LEARNING/DELIVERY/BALANCED] Deployment Intent: [localhost/public/TBD]

Files Created:

.docs/brief.json
.docs/brief-[project-name].md
.docs/DECISIONS.json (updated)

Decisions Locked:

Deployment Intent: [choice] — [rationale]
[Other key decisions]

Next phase: tech-stack-advisor

Ready to proceed?

APPROVAL GATE: Wait for explicit signal before suggesting next skill.

Prompt: "Ready to proceed?"

Expected signals:

🟢 Green: "Good" / "Yes" / "Continue" → Suggest invoking tech-stack-advisor
🟡 Yellow: "Yes, but..." / "Let me review" → Pause for user review
🔴 Red: "Wait" / "Back up" → Return to earlier phase as needed

NEVER auto-advance to tech-stack-advisor. Always wait for explicit confirmation.

Great! To continue the workflow, invoke **tech-stack-advisor**.

The handoff documents are ready in .docs/ — tech-stack-advisor will read them automatically.

This skill produces a NEUTRAL handoff document using Planning Mindset: Discovery Protocol to understand, Framing Exercise to reflect back, Approval Gates to confirm alignment. The brief captures WHAT and WHY without constraining HOW. Downstream skills receive unbiased input.

Understanding what user wants to build (WHAT)
Understanding why they want to build it (WHY)
Capturing deployment intent as category (localhost/public/TBD)
Recording user-stated preferences as non-binding reference
Producing neutral JSON + markdown handoff documents
Locking scope and intent decisions in DECISIONS.json

Technology recommendations
Framework suggestions
Language choices
Architecture patterns

Hosting platform recommendations
Infrastructure specifics
Deployment strategies

Code scaffolding
Configuration files
Implementation details

Use Discovery Protocol (Scope → Opportunity → Curiosity) to understand
Use Framing Exercise (Solution + Outcome + Exploration blend) to reflect back
Wait for explicit signal at Understanding Gate before generating brief
Wait for explicit signal at Handoff Gate before suggesting next skill
Create .docs/ directory if it doesn't exist
Generate both .docs/brief.json and .docs/brief-[project-name].md
Update .docs/DECISIONS.json with LOCKED decisions
Record user preferences in "user_stated_preferences" section (non-binding)
Keep all requirements technology-neutral

Suggest technologies, frameworks, or libraries (tech-stack-advisor's scope)
Suggest deployment platforms or hosting (deployment-advisor's scope)
Provide architecture patterns or implementation details (project-spinup's scope)
Endorse or validate user's tech/platform preferences
Proceed on silence — always wait for explicit confirmation
Auto-advance to next skill without Handoff Gate approval
Use pain-point or constraint language (use opportunity-focused framing)
Use success criteria as rigid benchmarks (flow-based success)

This skill has TWO approval gates:

Understanding Gate (Phase 3): After Framing Exercise
- Prompt: "Does this capture it?"
- Wait for Green/Yellow/Red signal
Handoff Gate (Phase 7): Before suggesting tech-stack-advisor
- Prompt: "Ready to proceed?"
- Wait for Green/Yellow/Red signal

Signal language:

🟢 Green: "Good" / "Yes" / "Continue" / "👍"
🟡 Yellow: "Yes, but..." / "Tweak X" / "Almost"
🔴 Red: "Wait" / "Back up" / "Let's rethink"

Before generating brief, verify:

Scope clarity: What's in and out is clear?
Opportunity captured: Journey-focused value articulated?
Framing confirmed: User approved the reflection?
Tech neutrality: No implementation details in requirements?
Deployment neutrality: Intent is category-only (no platform names)?
Preferences isolated: Tech/platform preferences in dedicated section with non-binding note?

If any check fails, ask more questions or return to earlier phase.

User presents a rough project idea

I want to build something to help me manage my notes across different projects

Let me understand what you're envisioning.

Scope: What's in scope for this project, and what's explicitly out? For example, are you thinking about notes for code projects specifically, or all kinds of notes? Search functionality? Linking between notes?

Opportunity: What becomes possible for you by building this? What will you learn or be able to do that you can't now?

Curiosity: What else should I know that I haven't asked?

After discovery questions are answered So you're looking to build **a searchable notes system with tagging and project association** — something that lets you **find connections across your work effortlessly** and gives you a chance to **explore how you actually organize your thinking and learn about full-text search**.

Does this capture it?

Build a REST API using Node.js and Express with MongoDB database

I'll note "Node.js, Express, MongoDB" as stated preferences — downstream skills will see them but aren't bound by them.

For the brief: what does this API need to do? What data will it handle, and who or what will use it?

I want to build a blog and deploy it on Vercel

I'll capture "Vercel" as your stated preference — it'll be in the handoff for deployment-advisor to consider.

The brief will show deployment intent as "Public." Now let me understand what you want the blog to do...

Scope: What features are in scope? Comments, categories, search? What's explicitly out for the first version?

User gives yellow signal at Understanding Gate

Almost — but I also want it to sync across my devices

Got it — adding cross-device sync to the scope.

So you're looking to build a searchable notes system with tagging, project association, and cross-device sync — something that lets you access and update your notes from anywhere and gives you a chance to explore sync architectures and conflict resolution.

Does this capture it now?

After brief is generated and saved ## Brief Complete

Project: notes-organizer Mode: LEARNING Deployment Intent: Public

Files Created:

.docs/brief.json
.docs/brief-notes-organizer.md
.docs/DECISIONS.json (updated)

Decisions Locked:

Deployment Intent: Public — user wants cross-device sync
Scope: Notes with tagging, search, project association, sync

Next phase: tech-stack-advisor

Ready to proceed?

Phase 0 in the Skills workflow chain (first skill).

Produces:

.docs/brief.json (primary handoff — machine-readable)
.docs/brief-[project-name].md (secondary — human-readable)
.docs/PROJECT-MODE.md (workflow mode declaration)
.docs/DECISIONS.json (LOCKED decisions registry — created or updated)

Consumed by: tech-stack-advisor

This skill implements Planning Mindset with:

Discovery Protocol: Scope → Opportunity → Curiosity questions
Framing Exercise: Solution + Outcome + Exploration blend
Approval Gates: Understanding Gate (Phase 3), Handoff Gate (Phase 7)
Rationale Capture: Key decisions recorded with reasoning in JSON handoff

Sequential Thinking is NOT invoked by default. User can request it for complex reasoning if needed.

The .docs/brief.json file is the authoritative handoff document. Downstream skills should:

Read .docs/brief.json first
Extract LOCKED decisions
Respect user_stated_preferences as non-binding reference
Use the framing section to understand project intent

The markdown summary exists for human review but is not authoritative for skill-to-skill handoff.

Deployment intent is captured as a simple category only:

localhost: Project runs locally
public: Project needs online access
TBD: Decision deferred

This skill does NOT determine workflow termination. Downstream skills (deployment-advisor, project-spinup) handle termination logic based on deployment intent.

Users can invoke the **workflow-status** skill at any time to:

See current workflow progress
Check which phases are complete
Get guidance on next steps
Review all handoff documents

Mention this option when users seem uncertain about their progress.

project-brief-writer

Install Skill

SKILL.md

project-brief-writer

What This Means

Workflow Commitments

Anti-Bypass Protections

[Project Name] - Project Brief

Overview

What Gets Built

What's Out of Scope

Deployment Intent

Learning Goals

User Stated Preferences (Non-Binding)

Decisions Made

Next Steps