validated-knowledge-synthesis
Transform raw, unorganized information into actionable knowledge through systematic validation. Use when users want to synthesize information from multiple sources (documents, URLs, transcripts, notes) into structured knowledge documents. Supports three document types - curated context (default, optimized for recall), guidance (implementation-focused narrative), and reference (quick lookup). Combines convergent synthesis with tension preservation to maintain productive contradictions. Triggers on requests like "synthesize this information", "create knowledge document from these sources", "transform these notes into actionable guidance", or "help me organize this research".
Best use case
validated-knowledge-synthesis is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Transform raw, unorganized information into actionable knowledge through systematic validation. Use when users want to synthesize information from multiple sources (documents, URLs, transcripts, notes) into structured knowledge documents. Supports three document types - curated context (default, optimized for recall), guidance (implementation-focused narrative), and reference (quick lookup). Combines convergent synthesis with tension preservation to maintain productive contradictions. Triggers on requests like "synthesize this information", "create knowledge document from these sources", "transform these notes into actionable guidance", or "help me organize this research".
Teams using validated-knowledge-synthesis should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/validated-knowledge-synthesis/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How validated-knowledge-synthesis Compares
| Feature / Agent | validated-knowledge-synthesis | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Transform raw, unorganized information into actionable knowledge through systematic validation. Use when users want to synthesize information from multiple sources (documents, URLs, transcripts, notes) into structured knowledge documents. Supports three document types - curated context (default, optimized for recall), guidance (implementation-focused narrative), and reference (quick lookup). Combines convergent synthesis with tension preservation to maintain productive contradictions. Triggers on requests like "synthesize this information", "create knowledge document from these sources", "transform these notes into actionable guidance", or "help me organize this research".
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Validated Knowledge Synthesis (VKS) Transform raw information into validated, actionable knowledge while preserving productive tensions. ## Parameters Acquire all required parameters upfront in a single prompt: | Parameter | Required | Description | |-----------|----------|-------------| | source_materials | Yes | Raw sources (direct text, file paths, URLs) | | synthesis_topic | Yes | Subject being synthesized | | target_audience | Yes | Intended users of the knowledge | | document_type | No | "curated context" (default), "guidance", or "reference" | | output_location | No | File path to save output | Support multiple input methods: direct text, file paths, URLs, or other user-preferred methods. ## Workflow ### 1. Source Validation Assess each source for: - Authority and credibility - Recency and relevance - Internal consistency - Citation quality Create a source validation matrix. Flag sources lacking sufficient validation. ### 2. Pattern Recognition Identify across sources: - Common themes and shared insights - Contradictory claims or competing frameworks - Gaps where sources don't address key aspects - Overlapping evidence strengthening claims Categorize relationships as **convergent** (ideas strengthen each other) or **tension-based** (separation maintains value). ### 3. Synthesis Strategy Selection **Apply convergence when:** - Ideas are complementary - Contradictions resolve at higher abstraction - Unified approach improves application - No valuable knowledge lost in combination **Apply tension preservation when:** - Contradictions generate new insights - Different contexts require different approaches - Forced convergence would flatten valuable complexity ### 4. Document Type Execution See [references/document-types.md](references/document-types.md) for detailed format specifications. **Curated Context** (default): Hybrid of guidance and reference. Clear sections distinguishing each. Optimized for ease of recall. **Guidance**: Narrative flow, problem-solution-implementation arc, 200+ words continuous prose before formatting, bullet points only for final checklists. **Reference**: Quick lookup, categorical organization, bullet-friendly, designed for scanning. ### 5. Writing Execution Apply these principles to all documents. See [references/writing-principles.md](references/writing-principles.md) for details. - **Reader Empathy**: Communicate key ideas in minimal words. Core tenet: "Learning how to communicate something in 30 seconds that takes most people 5 minutes is a HUGE unlock." - **Short Sentences**: Simple sentences build patience for complex concepts. - **Strong Verbs**: Use precise verbs. Avoid helpers (has, had), infinitives when direct verbs work, "to be" variations. - **Simple Words**: Choose simpler words (use not utilize, help not facilitate). ### 6. Apply Frameworks See [references/frameworks.md](references/frameworks.md) for complete framework details. **Golden Path Criteria**: Purpose & Audience, Clear & Concise, Structure & Logic, Evidence & Impact, Action & Execution. **Answer-Explain-Educate**: Lead with direct answer, support with key details, add important context. **What-So What-Now What**: Present facts, analyze consequences, propose recommendation. ### 7. Validation Verify: - Logical progression (premises support conclusions, no circular reasoning) - Narrative coherence (reader can follow logic without headers) - Flow validation (paragraphs connect logically) - Comprehension test (audience can understand and implement) ### 8. Output Generation Create synthesis document including: - Executive summary with key insights - Source validation matrix - Synthesis strategy decisions with rationale - Convergent knowledge with evidence - Preserved tensions with context boundaries - Implementation guidance Save to output_location if specified. ## Troubleshooting | Problem | Solution | |---------|----------| | Forced convergence weakens knowledge | Apply tension preservation instead | | Validation failures | Revisit synthesis strategy; clarify context boundaries | | Low-quality sources | Exclude or document limitations clearly | | Excessive complexity | Create layered documentation (summary, analysis, appendices) | | Fragmented narrative | Add transitions, embed lists in prose, test without formatting |
Related Skills
synthesize-knowledge-graph
Transform source materials into K-DAGs (Knowledge DAGs) — modular, curated domain knowledge structured as directed acyclic graphs with typed edges, mermaid visualization, and prose context. Use when users want to build knowledge graphs from documents, synthesize multiple sources into structured ontologies, intersect existing K-DAGs to discover emergent relationships, or create machine-readable knowledge structures that resist context rot. Triggers on: 'build a knowledge graph', 'create a K-DAG', 'intersect these knowledge sources', 'map the relationships between these documents', 'synthesize an ontology from these sources'.
writing-eval-sloptastic
Quantitative framework for detecting AI-generated "slop" in prose through systematic analysis of structural, lexical, rhetorical, and logical patterns. Use when analyzing text authenticity, evaluating writing quality, detecting AI-generated content, or assessing whether prose has characteristic AI patterns like excessive parallelism, abstraction laddering, chiasmus abuse, platitudes, tautologies, or rhetorical overengineering.
transcribing-youtube
Download and transcribe YouTube videos into clean, deduplicated Markdown documents with chapter headings. Wraps yt-dlp to fetch subtitles (manual or auto-generated), removes the rolling-text triplication artifacts from auto-subs, inserts chapter markers from video metadata, and produces both a timestamped transcript and a prose-only version. Use when the user wants to: (1) transcribe a YouTube video, (2) get a transcript or subtitles from YouTube, (3) create an InfoNugget from a video, (4) extract text from a YouTube URL or video ID, or (5) mentions yt-dlp, YouTube transcript, or video subtitles.
skill-resiliency
This skill should be used when the user asks to "add resiliency to a skill", "make this skill more robust", "improve error handling", "add validation mechanisms", "create self-correcting behavior", or discusses determinism, robustness, error correction, or homeostatic patterns in Agent Skills. Applies biological resiliency principles from Michael Levin's work to Agent Skill design.
prompt-driven-development
Transform rough ideas into detailed design documents with implementation plans. Use when a user wants to develop an idea into a complete specification, create a design document from a concept, plan a feature implementation, or mentions "PDD", "prompt-driven development", "idea to design", "design doc from idea", or wants to systematically refine requirements before building. Guides through requirements clarification, research, detailed design, and implementation planning.
codebase-summary
Analyze a codebase and generate comprehensive documentation including architecture, components, interfaces, workflows, and dependencies. Creates an AI-optimized knowledge base (index.md) and can consolidate into AGENTS.md, README.md, or CONTRIBUTING.md. Use when the user wants to document a codebase, create AGENTS.md, understand system architecture, generate developer documentation, or asks to "summarize the codebase".
Skill Development
This skill should be used when the user wants to "create a skill", "add a skill to plugin", "write a new skill", "improve skill description", "organize skill content", or needs guidance on skill structure, progressive disclosure, or skill development best practices for Claude Code plugins.
Plugin Structure
This skill should be used when the user asks to "create a plugin", "scaffold a plugin", "understand plugin structure", "organize plugin components", "set up plugin.json", "use ${CLAUDE_PLUGIN_ROOT}", "add commands/agents/skills/hooks", "configure auto-discovery", or needs guidance on plugin directory layout, manifest configuration, component organization, file naming conventions, or Claude Code plugin architecture best practices.
Plugin Settings
This skill should be used when the user asks about "plugin settings", "store plugin configuration", "user-configurable plugin", ".local.md files", "plugin state files", "read YAML frontmatter", "per-project plugin settings", or wants to make plugin behavior configurable. Documents the .claude/plugin-name.local.md pattern for storing plugin-specific configuration with YAML frontmatter and markdown content.
MCP Integration
This skill should be used when the user asks to "add MCP server", "integrate MCP", "configure MCP in plugin", "use .mcp.json", "set up Model Context Protocol", "connect external service", mentions "${CLAUDE_PLUGIN_ROOT} with MCP", or discusses MCP server types (SSE, stdio, HTTP, WebSocket). Provides comprehensive guidance for integrating Model Context Protocol servers into Claude Code plugins for external tool and service integration.
Hook Development
This skill should be used when the user asks to "create a hook", "add a PreToolUse/PostToolUse/Stop hook", "validate tool use", "implement prompt-based hooks", "use ${CLAUDE_PLUGIN_ROOT}", "set up event-driven automation", "block dangerous commands", or mentions hook events (PreToolUse, PostToolUse, Stop, SubagentStop, SessionStart, SessionEnd, UserPromptSubmit, PreCompact, Notification). Provides comprehensive guidance for creating and implementing Claude Code plugin hooks with focus on advanced prompt-based hooks API.
example-skill
This skill should be used when the user asks to "demonstrate skills", "show skill format", "create a skill template", or discusses skill development patterns. Provides a reference template for creating Claude Code plugin skills.