project-intake
Project Intake
Organize scattered project inputs into structured documentation, clarifying project boundaries and known/unknown items.
Workflow
- Scan whatever the user has provided — extract project goal, available inputs, and visible gaps
- If the goal is unclear or no concrete inputs exist, ask one question to unblock (e.g., "What problem is this project solving?")
- Ask one follow-up question at a time until you have enough to fill all 8 sections
- Write
docs/00-intake.mdto disk (createdocs/directory if needed) - Report the file path and ask if anything needs adjusting
When to Use
Use this skill when:
- User mentions "new project", "new feature", "build something"
- User provides PRD draft, prototype, screenshots, Figma links
- User describes ideas without formal documentation
- Team needs to clarify "what's known vs what's unknown"
- Before any detailed design work begins
Input Types
This skill processes the following input types (not all required, but will identify and document):
- Initial PRD or requirement description
- Prototype demos (Figma, HTML demo, screenshots, videos)
- Interaction specifications or user flow diagrams
- Existing code repositories or modules
- User's verbal descriptions or supplementary notes
- Competitive analysis or reference cases
Output Document
Generate docs/00-intake.md (create docs directory if it doesn't exist)
Document Structure
Organize content with the following structure, keeping each section concise:
1. Project Goal (One Sentence)
Express the core project goal in one sentence. No more than two lines.
2. Current Available Inputs
List all provided inputs including:
- PRD/requirement documents (if any)
- Prototype/design files or links
- Code repositories or modules
- User's supplementary descriptions
Mark the status of each item: "completed" or "draft/initial"
3. Missing Inputs
List inputs required for project kickoff but not yet provided, such as:
- Key business process diagrams
- User role definitions
- Success criteria
- Existing system boundaries
4. Confirmed Primary Roles
List user roles or system roles involved. No need for detailed permission definitions.
5. Confirmed Primary Modules
List identified core functional modules or system components.
6. Demo Reference Type
Clearly mark:
- Visual Reference: Demo serves as UI/visual style reference only, not representing interaction behavior
- Behavior Reference: Demo shows complete user interaction flow, behaviors need to be implemented
7. Existing Code/Repository Boundaries
If existing code exists:
- Related repositories or modules
- Technology stack of the code
- Which parts might be reused
8. Unresolved Items List
List all items that are not yet determined and need clarification. One sentence per item.
Writing Principles
- Keep it concise: 3-5 lines per section, don't expand into details
- Lock down boundaries: Focus on clarifying "known vs unknown", not writing detailed requirements
- Distinguish facts from assumptions: Mark what user confirmed vs what's inferred
- Don't write PRD: Don't expand business processes or feature details here - these belong in PRD phase
Completion Criteria
Ensure at completion:
- Project goal clearly expressed in one sentence
- All available inputs listed with status marked
- Missing inputs clearly listed, team knows what to collect next
- Confirmed roles and modules listed
- Demo reference type clearly marked
- Code boundaries identified (if applicable)
- All unresolved items listed
Output Location
If user doesn't specify output location, default to:
docs/00-intake.md
Follow user's specified location if provided.
Always write the file to disk. Do not output the intake document only in the conversation.
More from go-sphere/skills
ent-seed-sql-generator
Generate deterministic INSERT SQL seed data from Go Ent schemas and mixed inputs. This skill is REQUIRED whenever you need to create seed SQL for development or testing - it handles entity inference, relationship integrity, stable IDs, and dialect-specific SQL generation including JSON, arrays, and complex types. Use this skill for any task involving seed data, test fixtures, demo initialization, or database population from Ent schema definitions, even if the user doesn't explicitly mention "seed" or "SQL".
27pure-admin-crud-generator
Generate CRUD pages and router modules for pure-admin-thin from local swagger API definitions. MUST be used whenever you need to scaffold admin list/edit/detail pages, dashboard views, or route configurations from existing API methods in src/api/swagger/Api.ts. This skill replaces manual Vue page creation - use it for any admin panel development task involving API-driven pages.
25proto-api-generator
Design proto3 + HTTP API contracts for go-sphere scaffold projects from prompts, input folders, or requirement docs with mock data. Use when defining service APIs, selecting between entpb/shared/custom messages, and enforcing scaffold conventions, router-safety rules, and service-local error placement. This skill is REQUIRED for any proto API design task in go-sphere scaffold - always use it instead of writing proto files from scratch.
21sphere-feature-workflow
Implement end-to-end feature changes in go-sphere scaffold projects by following sphere-layout conventions and generation workflow. Use when adding or modifying APIs, protobuf contracts, Ent schemas, bind/map registration, service logic, or cross-layer refactors that must stay protocol-first and avoid manual edits to generated files. This skill is REQUIRED for any task involving go-sphere proto files, Ent schemas, service implementations, or generation commands (make gen/proto, make gen/docs, make gen/wire).
19proto-service-generator
Generate or complete Go service implementations from protobuf-generated HTTP interfaces in go-sphere scaffold projects. Use when you need to create `internal/service/<module>/*.go` files, add missing method implementations to existing services, or generate compilable stubs for new proto endpoints. Trigger for: service implementation, proto handler, append-only update, interface assertion, CRUD via Ent, stub method generation.
18ent-schema-generator
Design and generate Go + Ent database schemas for sphere-layout projects from requirements. Use when users describe data models, entity relationships, database tables, or schema changes — including prompts, Markdown docs, existing proto/service files, or demo behavior. Produces implementation-ready schema plans with field definitions, ID strategies, relation designs, indexes, entproto annotations, and bind/render/service integration guidance.
16