core-blueprint

Core Blueprint — Inside-Out Learning Outline

Philosophy: Inside-Out, Core-First

The fastest way to understand any project's internals is to start at the heart — the minimal core that everything else depends on. The source project can be in any language (Python, Go, Rust, Node.js, C#, Ruby, Java, etc.) — the output is always a simplified Java reimplementation that captures the essential architecture. Instead of starting from the public API surface and tracing inward (API-first approach), this skill:

1. Identifies the heart — the minimal core component(s) that everything else depends on
2. Builds outward progressively — each feature plugs into the existing system at a clear integration point, extending the core's capabilities
3. Orders by dependency — foundations first, extensions later, ensuring each feature has a solid base to build on

This approach works because:

• Each feature has a clear foundation — you never build something that depends on something not yet built
• You understand how the core works before seeing how it's extended
• Core architectural patterns transcend language — analyzing a Go or Python project reveals the same design principles you'll reimplement in Java
• You see the big picture — Mermaid diagrams show integration points, component relationships, and the progressive build path

MANDATORY: Use Extended Thinking

Use extended thinking for the analysis phase. The quality of the outline depends entirely on deep upfront reasoning about the source project's architecture. Before writing any output:

• Identify the source project's language and technology stack
• Map the full type/module/class hierarchy of core packages (adapting to the source language's conventions)
• Identify the "heart" — the minimal core that everything else depends on
• Trace key execution flows end-to-end
• Plan how source language constructs map to Java equivalents (e.g., Go interfaces to Java interfaces, Python decorators to Java annotations, Rust traits to Java interfaces)
• Determine which components can be meaningfully simplified vs which need near-full fidelity
• Plan the progressive enhancement order — each feature must build on previous ones