design

Define cross-layer feature architecture patterns for SpawnForge systems.

5|1|Updated Feb 11, 2026
One-click install
npx skills add https://github.com/Tristan578/project-forge --skill design-tristan578
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: design
Source: https://github.com/Tristan578/project-forge/tree/main/.claude/skills/design
Command: npx skills add https://github.com/Tristan578/project-forge --skill design-tristan578

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

SpawnForge teams require a coherent, scalable blueprint to evaluate and plan cross-layer feature work across the Rust engine, React UI, and MCP command surfaces. This design skill provides a consistent framework to reason about architecture, constraints, and trade-offs so features integrate cleanly without violating the sandwich architecture.

Core Features & Use Cases

  • Sandwich-architecture enforcement: core/bridge isolation; UI actions route through JSON commands; engine updates flow through events to JS/React.
  • Cross-layer design decisions: ensure ECS components, render backends (WebGPU/WebGL2), and export/runtime gating stay coherent across Rust, JS, and TypeScript boundaries.
  • Undo/AI parity: enforce undoable actions, MCP commands, chat handlers, and structured data for AI reasoning.
  • Design patterns & governance: codified patterns like Command-Event Architecture, EntitySnapshot, and feature-gating rules guide feature reviews.
  • Validation & quality: continuous spec validation, architecture checks, and performance budgets.

Quick Start

Outline a high-level design spec for a new SpawnForge feature, mapping Rust components, bridge interfaces, and runtime implications.

Frequently Asked Questions about design

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I plan a scalable architecture for features spanning Rust, React, and MCP command surfaces?

To plan a scalable architecture across Rust, React, and MCP, use a design framework enforcing sandwich architecture with core/bridge isolation. This ensures UI actions route through JSON commands and engine updates flow through events to JS/React cleanly.

What is sandwich architecture in cross-layer engine and UI design?

Sandwich architecture is a design pattern enforcing core and bridge isolation. It requires UI actions to route through JSON commands to the engine, with engine updates flowing back through events to JS/React, ensuring clear interaction boundaries.

How do I ensure undo support and AI parity when designing MCP commands?

Ensure undo support and AI parity by enforcing undoable actions, standardized MCP commands, chat handlers, and structured data. This provides the structured reasoning required for AI to process and reverse engine state changes accurately.

Can I use this architecture framework to evaluate ECS components and WebGPU rendering boundaries?

Yes, you can evaluate ECS components and render backends like WebGPU or WebGL2 using this framework. It ensures components, render backends, and export gating stay coherent across Rust, JS, and TypeScript interaction boundaries.

What are the limitations of relying on a bridge interface for engine updates?

A limitation of bridge interfaces is the strict requirement for continuous spec validation and performance budgets. You must rigorously map interaction boundaries to prevent JSON command routing and event flow bottlenecks between Rust and React.

What's the best way to document feature architecture for SpawnForge?

The best way to document feature architecture is outlining a high-level design spec that maps Rust components, bridge interfaces, and runtime implications. This codifies decision criteria, EntitySnapshot patterns, and feature-gating rules for review.