Code Research Crafter

Craft comprehensive research proposals from code analysis to GitHub RFC publication.

Overview

This skill provides a complete 6-phase workflow for deep codebase research and professional proposal crafting:

1. Code Analysis - Understanding existing implementation through systematic exploration
2. Academic Research - Finding relevant papers, algorithms, and prior art
3. Community Analysis - Reviewing GitHub issues, discussions, and maintainer feedback
4. Solution Design - Architecture design with data models and phased implementation plans
5. Documentation - Generating structured technical documents (Chinese/English)
6. RFC Publication - Writing and submitting professional RFCs to GitHub

When to Use

Use this skill when you need to:

• Analyze an open-source codebase and propose enhancements
• Research technical problems with academic rigor
• Design system architectures with evidence-based decisions
• Create professional RFCs for open-source communities
• Document complex technical proposals with proper citations

Workflow

Phase 1: Problem Discovery & Code Analysis

Step 1: Identify the target area

• Search for relevant files in the codebase using glob patterns
• Look for GitHub issues related to the topic
• Check existing documentation (docs/, README, etc.)

Step 2: Deep code analysis

# Find relevant source files
glob **/[module]*/**/*.ts
glob **/[component]*.ts

# Read key implementation files
read src/[module]/[key-file].ts

# Search for specific patterns
grep "[pattern]" src/**/*.ts

Step 3: Document findings

• Note current architecture limitations
• Identify specific code locations and their roles
• Quantify problems (e.g., "50% of files lack documentation")

Phase 2: Academic & Community Research

Step 1: Search for academic papers

• Use WebSearch to find relevant research papers
• Focus on papers from 2024-2025
• Look for algorithms, data structures, and approaches

Step 2: Analyze GitHub community

• Search for related issues and discussions
• Check maintainer responses and feedback
• Identify pain points from user comments

Step 3: Extract key insights

• Document relevant algorithms and approaches
• Note community sentiment and feature requests
• Identify gaps between current implementation and best practices

Phase 3: Solution Design

Step 1: Define design principles

• Evidence-based: Reference specific code locations
• Academic rigor: Cite recent papers
• Human-centered: Use organization analogies
• Cost-aware: Track token/performance implications

Step 2: Architect the solution

• Design layered architecture (Foundation → Enhancement → Intelligence → Governance)
• Define data models (dual-track: user-defined + system-learned)
• Plan visibility tiers (private/team/global)

Step 3: Plan implementation phases

• Phase 1: Foundation (data collection)
• Phase 2: Enhancement (builds on Phase 1)
• Phase 3: Intelligence (AI/ML on data)
• Phase 4: Governance (control/monitoring)

Phase 4: Documentation Generation

Step 1: Create structured documents

• Use python-docx for professional formatting
• Include table of contents, headers, and proper structure
• Add citations and references

Step 2: Generate bilingual versions

• Create English version for international communities
• Create Chinese version for local stakeholders
• Ensure consistent terminology

Phase 5: English RFC Writing

Step 1: Structure the RFC

# RFC: [Title]

## Problem Statement
[Quantified problem with code evidence]

## Prior Art
[Academic research and existing solutions]

## Proposed Solution
[Architecture, data models, implementation phases]

## Trade-offs
[Cost analysis, migration path, risks]

## Call for Collaboration
[How to get involved]

Step 2: Follow community conventions

• Use existing RFCs as templates
• Reference GitHub issues and discussions
• Include code examples and diagrams

Phase 6: GitHub Publication

Step 1: Prepare the RFC

• Create markdown file in appropriate location
• Ensure proper formatting and links
• Add relevant labels

Step 2: Submit to GitHub

• Create issue or discussion with RFC content
• Reference related issues
• Tag relevant maintainers

Step 3: Engage the community

• Respond to comments and questions
• Update RFC based on feedback
• Track implementation progress

Output Examples

Memory Consolidation RFC

Combines Zettelkasten + PPR + Sleep Consolidation approaches for knowledge management.

Multi-Agent Collaboration RFC

Features Capability Profiling and Shared Blackboard architecture for agent coordination.

Temporal Decay Bug Fixes

Expands date pattern recognition in configuration interfaces.

Best Practices

1. Quote specific code locations - Always reference file paths and line numbers
2. Quantify problems - Use metrics like "50% of files" or "3x performance improvement"
3. Cite recent research - Prefer papers from 2024-2025
4. Use analogies - Make complex concepts accessible with organization/workflow analogies
5. Design for adoption - Include migration paths and gradual rollout plans
6. Track costs - Document token usage, performance implications, and resource requirements
7. Engage early - Reference existing issues and invite collaboration from the start

Success Metrics

A successful Code Research Crafter output should:

• ✅ Receive community engagement (comments, reactions)
• ✅ Quantify problems with code evidence
• ✅ Reference academic research
• ✅ Provide phased, actionable implementation plans
• ✅ Be clear for all audiences (technical and non-technical)

Tools & Resources

• Code Analysis: glob, grep, read
• Academic Research: WebSearch, WebFetch
• Documentation: python-docx for professional document generation
• Publication: browser_use_desktop for GitHub submission
• Version Control: desktop_terminal_execute for Git operations

License

MIT License - See LICENSE.txt for details.