Index of every page on this site: llms.txt
All skills
makenotion avatar

/spec-to-implementation

@016c74f official
Run it yourself

Converts Notion product or technical specs into implementation plans, linked tasks, and evidence-based progress updates. Use for planning or implementing a spec, creating tasks from requirements, or reconciling implementation with spec changes.

  • 20 files
  • 65.3 KB
  • Updated 2 weeks ago
  • GitHub
Use this Skill: https://skilld.dev/gh/makenotion/claude-code-notion-plugin/spec-to-implementation

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

referencetask-creation.md

≈2.1k tokens on demand. Your agent reads this file only when SKILL.md points to it.

Task creation from specs

Use this guide when task creation is requested. Examples are illustrative: use the exposed tool schema and actual database properties. Fetch a supplied database directly, reuse its schema for the task, and check for existing work before creating new pages. Do not create a separate plan unless requested or needed for the work.

Finding the Task Database

Before creating tasks, locate the task database:

1. Search for task database:
   Notion:notion-search
   query: "Tasks" or "Task Management" or "[Project] Tasks"

2. Fetch database schema:
   Notion:notion-fetch
   id: "database-id-from-search"

3. Identify data source:
   - Look for <data-source url="collection://..."> tags
   - Extract collection ID for parent parameter

4. Note schema:
   - Required properties
   - Property types and options
   - Relation properties for linking

Example:
Notion:notion-search
query: "Engineering Tasks"
query_type: "internal"

Notion:notion-fetch
id: "tasks-database-id"

Result: collection://abc-123-def for use as parent

Task Breakdown Strategy

Size guidelines

Prefer a clear deliverable with testable acceptance criteria and explicit prerequisites. Split work when it has independent outcomes or cannot be verified as one task; combine trivial steps that serve the same outcome. Respect team conventions and the scope of the spec. Do not impose a minimum task count or a fixed duration. Small changes can be one task; complex features need more detail.

Granularity by Phase

Early phases: Larger tasks acceptable

  • "Design database schema"
  • "Set up API structure"

Middle phases: Medium-sized tasks

  • "Implement user authentication"
  • "Build dashboard UI"

Late phases: Smaller, precise tasks

  • "Fix validation bug in form"
  • "Add loading state to button"

Task Creation Pattern

For each requirement or work item:

1. Identify the work
2. Determine task size
3. Create task in database
4. Set properties
5. Write task description
6. Link to spec/plan

Creating Task

Use Notion:notion-create-pages:

parent: {
  type: "data_source_id",
  data_source_id: "collection://tasks-db-uuid"
}

properties: {
  "[Title Property]": "Task: [Clear task name]",
  "Status": "To Do",
  "Priority": "[High/Medium/Low]",
  "[Project/Related]": ["spec-page-id", "plan-page-id"],
  "Assignee": "[Person]" (if known),
  "date:Due Date:start": "[Date]" (if applicable),
  "date:Due Date:is_datetime": 0
}

content: "[Task description using template]"

Task Description Template

# [Task Name]

## Context

Implementation task for <mention-page url="...">Feature Spec</mention-page>

Part of <mention-page url="...">Implementation Plan</mention-page> - Phase [N]

## Objective

[What this task accomplishes]

## Requirements

Based on spec requirements:

- [Relevant requirement 1]
- [Relevant requirement 2]

## Acceptance Criteria

- [ ] [Specific, testable criterion]
- [ ] [Specific, testable criterion]
- [ ] [Specific, testable criterion]

## Technical Approach

[Suggested implementation approach]

### Components Affected

- [Component 1]
- [Component 2]

### Key Decisions

- [Decision point 1]
- [Decision point 2]

## Dependencies

### Blocked By

- <mention-page url="...">Prerequisite Task</mention-page> or None

### Blocks

- <mention-page url="...">Dependent Task</mention-page> or None

## Resources

- [Link to design mockup]
- [Link to API spec]
- [Link to relevant code]

## Estimated Effort

[Time estimate]

## Progress

[To be updated during implementation]

Task Types

Infrastructure/Setup Tasks

Title: "Setup: [What's being set up]"
Examples:
- "Setup: Configure database connection pool"
- "Setup: Initialize authentication middleware"
- "Setup: Create CI/CD pipeline"

Focus: Getting environment/tooling ready

Feature Implementation Tasks

Title: "Implement: [Feature name]"
Examples:
- "Implement: User login flow"
- "Implement: File upload functionality"
- "Implement: Dashboard widget"

Focus: Building specific functionality

Integration Tasks

Title: "Integrate: [What's being integrated]"
Examples:
- "Integrate: Connect frontend to API"
- "Integrate: Add payment provider"
- "Integrate: Link user profile to dashboard"

Focus: Connecting components

Testing Tasks

Title: "Test: [What's being tested]"
Examples:
- "Test: Write unit tests for auth service"
- "Test: E2E testing for checkout flow"
- "Test: Performance testing for API"

Focus: Validation and quality assurance

Documentation Tasks

Title: "Document: [What's being documented]"
Examples:
- "Document: API endpoints"
- "Document: Setup instructions"
- "Document: Architecture decisions"

Focus: Creating documentation

Bug Fix Tasks

Title: "Fix: [Bug description]"
Examples:
- "Fix: Login error on Safari"
- "Fix: Memory leak in image processing"
- "Fix: Race condition in payment flow"

Focus: Resolving issues

Refactoring Tasks

Title: "Refactor: [What's being refactored]"
Examples:
- "Refactor: Extract auth logic to service"
- "Refactor: Optimize database queries"
- "Refactor: Simplify component hierarchy"

Focus: Code quality improvement

Sequencing Tasks

Critical Path

Identify must-happen-first tasks:

1. Database schema
2. API foundation
3. Core business logic
4. Frontend integration
5. Testing
6. Deployment

Parallel Tracks

Tasks that can happen simultaneously:

Track A: Backend development
- API endpoints
- Business logic
- Database operations

Track B: Frontend development
- UI components
- State management
- Routing

Track C: Infrastructure
- CI/CD setup
- Monitoring
- Documentation

Phase-Based Sequencing

Group by implementation phase:

Phase 1 (Foundation):
- Setup tasks
- Infrastructure tasks

Phase 2 (Core):
- Feature implementation tasks
- Integration tasks

Phase 3 (Polish):
- Testing tasks
- Documentation tasks
- Optimization tasks

Priority Assignment

P0/Critical

  • Blocks everything else
  • Core functionality
  • Security requirements
  • Data integrity

P1/High

  • Important features
  • User-facing functionality
  • Performance requirements

P2/Medium

  • Nice-to-have features
  • Optimizations
  • Minor improvements

P3/Low

  • Future enhancements
  • Edge case handling
  • Cosmetic improvements

Estimation

Estimates when useful

Use the team's existing scale and label assumptions. Story points are relative; do not convert them to days without an established team convention. Include time estimates when requested or useful for planning, with uncertainty for unknowns. Do not invent due dates or commitments to fill a template.

Estimation Factors

Consider:

  • Complexity
  • Unknowns
  • Dependencies
  • Testing requirements
  • Documentation needs

Task Relationships

Parent Task Pattern

For large features:

Parent: "Feature: User Authentication"
Children:
- "Setup: Configure auth library"
- "Implement: Login flow"
- "Implement: Password reset"
- "Test: Auth functionality"

Dependency Chain Pattern

For sequential work:

Task A: "Design database schema"
↓ (blocks)
Task B: "Implement data models"
↓ (blocks)
Task C: "Create API endpoints"
↓ (blocks)
Task D: "Integrate with frontend"

Related Tasks Pattern

For parallel work:

Central: "Feature: Dashboard"
Related:
- "Backend API for dashboard data"
- "Frontend dashboard component"
- "Dashboard data caching"

Bulk Task Creation

When creating many tasks:

For each work item in breakdown:
  1. Determine task properties
  2. Create task page
  3. Link to spec/plan
  4. Set relationships

Then:
  1. Update plan with task links
  2. Review sequencing
  3. Assign tasks when requested and assignees are known

Task Naming Conventions

Be specific: ✓ "Implement user login with email/password" ✗ "Add login"

Include context: ✓ "Dashboard: Add revenue chart widget" ✗ "Add chart"

Use action verbs:

  • Implement, Build, Create
  • Integrate, Connect, Link
  • Fix, Resolve, Debug
  • Test, Validate, Verify
  • Document, Write, Update
  • Refactor, Optimize, Improve

Validation Checklist

Before finalizing tasks:

☐ Each task has clear objective ☐ Acceptance criteria are testable ☐ Dependencies identified ☐ Independently verifiable scope ☐ Priority assigned ☐ Linked to spec/plan ☐ Proper sequencing ☐ Resources noted

Source: SKILL.md on GitHub

No rule matched.

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

No third-party reports yet.

Signed by skilld at 016c74f. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub last week.

Activeupdated 2 weeks ago

README badge

README badge for makenotion/claude-code-notion-plugin/spec-to-implementation