Development

Guide developers in building browser modules within the layered Space Agent runtime.

5|Updated May 6, 2026
One-click install
npx skills add https://github.com/binary16labs/prime-silo --skill development-binary16labs
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Development
Source: https://github.com/binary16labs/prime-silo/tree/main/app/L0/_all/mod/_core/admin/ext/skills/development
Command: npx skills add https://github.com/binary16labs/prime-silo --skill development-binary16labs

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It solves confusion about how to correctly add new browser modules to the layered Space Agent runtime, including where code should live and how extension/component/Alpine store composition works.

Core Features & Use Cases

  • Layer-appropriate module placement: Use the correct repo-owned vs runtime state layers (L0 for durable code; L1/L2 for overrides and user state).
  • Correct module layout and namespacing: Follow the mod/<author>/<repo>/... browser module structure and keep adapters thin.
  • Deterministic UI composition guidance: Understand how page shells, HTML extension anchors, components, Alpine stores, and JS extension hooks fit together to power auditable, maintainable frontend behavior.

Quick Start

When you need to add a new UI module, create the first-party feature code under the appropriate L0 path, then add a thin ext/html/... adapter that mounts an existing component and delegate state and behavior to a space.fw.createStore(...)-backed store.

Frequently Asked Questions about Development

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

FAQPage Schema
How do I add a new browser module to a layered frontend architecture?

To add a new browser module, place durable first-party feature code in the L0 layer, then add a thin HTML extension adapter to mount components and delegate state to an Alpine store. This ensures maintainable frontend behavior across the layered runtime.

What is the correct module layout and namespacing for browser modules?

The correct module layout uses a `mod/<author>/<repo>/...` browser module structure. Keeping adapters thin within this namespacing convention ensures deterministic UI composition and clear separation between repo-owned code and runtime state layers.

How does component composition work with Alpine stores and HTML extension anchors?

Component composition works by wiring page shells to HTML extension anchors, mounting components, and routing state through Alpine stores. JS extension hooks connect to `space.extend` seams, linking UI elements to store-backed state for auditable behavior.

When do I need to use L0, L1, or L2 placement rules in a runtime?

Use L0 for durable repo-owned code, L1 for overrides, and L2 for user state. Adhering to these layer placement rules prevents confusion when adding new UI modules and ensures correct separation between first-party features and runtime modifications.

What is the best way to wire admin UI features using extension hooks?

The best way to wire admin UI features is to implement JS extension hooks at the `space.extend` seams. This connects the admin interface components to the Alpine store, ensuring deterministic state management and auditable frontend behavior.

Why does my frontend state break when adding new HTML extension anchors?

Frontend state breaks when code violates layer placement rules or uses thick adapters instead of delegating state. Ensure your HTML extension anchors mount existing components and route state through `space.fw.createStore(...)` to maintain deterministic composition.