PRD-to-Fibery Sync

Sync a PRD document into a Fibery workspace by extracting features, development tasks, milestones, and acceptance criteria, then creating them as structured entities in Fibery.

Prerequisites

To run this skill, two pieces of information are needed:

Fibery workspace URL (e.g., myworkspace.fibery.io)
Fibery API token (from Fibery → Settings → API Tokens)

If not provided as arguments, prompt the user for these values.

Workflow

Step 1: Read the PRD

Read the PRD file at $ARGUMENTS. If no path is provided, ask the user which PRD to sync.

Parse the PRD and extract:

Features — distinct capabilities or components described in the PRD (look for "Key Features", "Features", "Plan of Record", or similar sections)
Tasks — development work items under each feature (look for sub-sections, bullet points describing implementation work, or generate sensible dev tasks from feature descriptions)
Milestones — time-bound delivery phases (look for "Milestones", "Timeline", "Development Plan", or similar sections)
Acceptance criteria — testable conditions for each task (look for "Acceptance Criteria", "Key Flows" with criteria, requirements, or derive from feature specifications)

For each task, determine a priority:

Critical — safety-critical, regulatory, or blocking
High — core functionality, must-have for MVP
Medium — important but not blocking
Low — nice-to-have, analytics, logging

Step 2: Get Fibery Credentials

If workspace and token are not already known from the conversation, ask the user:

"What is your Fibery workspace URL?" (e.g., myworkspace.fibery.io)
"What is your Fibery API token?"

Step 3: Discover Fibery Schema

Run the discovery script to understand the workspace structure:

python3 scripts/fibery_sync.py discover <workspace> <token>

This returns all entity types, their fields, workflow states, and priority values. Use this to:

Identify the correct type names (e.g., Product Development/Features, Product Development/Tasks)
Find the title field for each type (marked with ui/title?)
Find available workflow states and their UUIDs
Find available priority values and their UUIDs
Identify parent-child relationships (e.g., Task → Feature)

If no Feature or Task type exists, inform the user and ask how to proceed.

Step 4: Create Features

For each feature extracted from the PRD:

python3 scripts/fibery_sync.py create_batch <workspace> <token> "<FeatureType>" '<entities_json>'

Set features to an appropriate initial workflow state (e.g., "Ready for Dev", "Idea", or whatever the first meaningful state is).

Step 5: Push Feature Descriptions

Get document secrets for the created features:

python3 scripts/fibery_sync.py get_secrets <workspace> <token> "<FeatureType>" '<names_json>'

Then update each feature's rich text description with the PRD content:

python3 scripts/fibery_sync.py update_doc <workspace> <token> <secret> "<markdown_content>"

Feature descriptions should include:

Overview of the feature from the PRD
Key rules or constraints
Related architecture decisions
Which milestone it belongs to

Step 6: Create Tasks Under Features

For each feature, create its development tasks with:

Parent feature link (relation field)
Priority (mapped to workspace priority enum values)
Initial workflow state (e.g., "To Do")

python3 scripts/fibery_sync.py create_batch <workspace> <token> "<TaskType>" '<entities_json>'

Step 7: Push Task Descriptions with Acceptance Criteria

Get document secrets for all tasks, then update each with:

Task heading
Acceptance Criteria section with checkbox items (- [ ])

Format:

## Task Name

### Acceptance Criteria
- [ ] First criterion
- [ ] Second criterion
- [ ] Third criterion

Step 8: Create Milestones (if applicable)

If the PRD has milestones and the workspace has a Milestone type, create them. If no Milestone type exists, offer to create one:

python3 scripts/fibery_sync.py create_type <workspace> <token> "<Space>/Milestones" '<fields_json>'

Then create milestone entities with descriptions including:

Timeline
Key deliverables
Related features
Success criteria or checklists

Step 9: Report Summary

After all entities are created, output a summary table:

## Fibery Sync Complete

| Category | Count | Details |
|----------|-------|---------|
| Features | N     | List of names |
| Tasks    | N     | Breakdown by feature |
| Milestones | N   | With timelines |

All tasks include acceptance criteria checklists.

API Reference

For detailed Fibery API documentation including authentication, entity commands, rich text workflow, schema creation, and known gotchas, see references/fibery-api.md.

Script Reference

The scripts/fibery_sync.py script provides these commands:

discover — schema discovery (types, fields, states, priorities)
create_entity — create single entity
create_batch — create multiple entities
query — run entity query
get_secrets — get document secrets for rich text updates
update_doc — update a rich text document
create_type — create a new entity type

All commands use Python stdlib only (no external dependencies required).

fibery-sync