prose-synthesize

Original：🇺🇸 English

Translated

Synthesize unstructured thinking into a structured, actionable plan. Use when user provides stream-of-consciousness thoughts, scattered notes, or a brain dump and needs them organized into a coherent plan with goals, actions, and priorities. Trigger phrases: "synthesize", "organize my thoughts", "turn this into a plan", "make sense of this", "structure this", "formalize these notes", "what should I do with all this".

11installs

Sourcelaurigates/claude-plugins

Added on2026-03-14

NPX Install

npx skill4agent add laurigates/claude-plugins prose-synthesize

SKILL.md Content

View Translation Comparison →

/prose:synthesize

Synthesize unstructured thinking into a structured, actionable plan — impose order on chaos.

When to Use This Skill

Use this skill when...	Use something else when...
User dumps stream-of-consciousness thoughts	Text is already structured but verbose → `/prose:distill`
Scattered notes need organizing into a plan	Need to capture session learnings → `/project:distill`
Brain dump needs goals, actions, priorities extracted	Need to write a plan from scratch with no input → `/blueprint:init`
User says "make sense of this", "organize this"	Document needs style/tone adjustment → `prose-tone` (planned)

Core Principles

Synthesis is the complement of analysis. Analysis breaks apart; synthesis combines fragments into a coherent whole. The input is scattered thinking — the output is structured intent.

What Makes a Good Synthesized Plan

Each element answers a specific question:

Element	Question it answers
Objective	What are we trying to achieve?
Key decisions	What needs deciding before acting?
Actions	What specific things need doing?
Dependencies	What blocks what?
Open questions	What's still unclear?

Parameters

Parse

$ARGUMENTS

:

If prose is provided inline, synthesize it directly
If a file path is provided, read and synthesize the file contents
If no arguments, ask the user to provide their unstructured thinking

Execution

Execute this synthesis workflow:

Step 1: Absorb the input

Read all provided text without editing or filtering. Identify:

Total volume (rough word count)
Density of ideas — scattered vs. loosely organized
Whether there's an implicit goal or the user is still exploring
Tone — brainstorming, planning, venting, or exploring

Step 2: Extract and tag ideas

Work through the input and internally classify each distinct idea:

GOAL — something the user wants to achieve
CONSTRAINT — a limitation or boundary condition
DECISION — a choice that needs making
ACTION — a concrete step that could be taken
QUESTION — something unresolved or uncertain
CONTEXT — background that informs the plan
ASIDE — tangential thought (preserve but deprioritize)

Do not discard anything yet. Do not show tags to the user.

Step 3: Cluster by theme

Group ideas into natural clusters:

Ideas addressing the same goal
Actions depending on the same decision
Questions blocking the same cluster of actions

Name each cluster with a short descriptive label.

Step 4: Find the spine

Identify the core through-line — the primary objective connecting the most clusters. This becomes the plan's backbone. Other clusters are supporting or parallel tracks.

Step 5: Build the plan

Structure the output using this format. Include only sections that have content:

## Objective

<1-2 sentence statement of what this plan achieves>

## Key Decisions

<Decisions that need making before or during execution. Note options if the user mentioned them.>

## Plan

<Ordered actions grouped by theme/phase. Numbered lists for sequences, bullets for parallel items.>

## Dependencies

<What blocks what — only if meaningful dependencies exist>

## Open Questions

<Unresolved items needing answers before the plan is complete>

## Parked Ideas

<Tangential thoughts worth preserving but outside the core plan>

Step 6: Validate completeness

Check the plan against the original input:

Is every goal addressed?
Is every constraint respected?
Are the user's questions surfaced, not buried?
Did anything important get lost in synthesis?

If the input was exploratory (no clear goal), say so in the objective and frame the plan as "potential directions" rather than commitments.

Handling Ambiguity

Situation	Approach
Multiple possible goals	Present as alternatives under Key Decisions
Contradictory ideas	Surface the contradiction explicitly
Vague but directional	Interpret the direction, note the interpretation
Pure exploration (no goal)	Organize by theme, suggest possible goals

Example

Input: "I need to fix the auth system. Also the tests are broken. Maybe we should move to JWT. The deployment pipeline keeps failing too. Sarah mentioned something about rate limiting. We should probably do a security audit at some point. Oh and the docs are out of date."

Synthesized:

Objective: Stabilize and secure the authentication system while addressing related infrastructure issues.

Key Decisions:

JWT migration — move to JWT or fix current auth? (Affects scope of all auth work)

Plan:

Fix immediate blockers

Fix broken tests (unblocks everything else)

Fix deployment pipeline failures

Auth system

Decide JWT migration

Implement fix or migration based on decision

Add rate limiting (per Sarah's input)

Hardening

Security audit

Update documentation

Open Questions:

What specifically did Sarah say about rate limiting?

What's breaking in the deployment pipeline? (may be auth-related)

Agentic Optimizations

Context	Approach
Short input (< 200 words)	Synthesize inline, present plan directly
Medium input (200-1000 words)	Full synthesis workflow, structured plan output
Long input or file (> 1000 words)	Read file, full synthesis, write plan to file
Already semi-structured input	Preserve existing structure, fill gaps
No clear goal in input	Organize by theme, present as exploration map