Design Principles

A framework's behavior is shaped by the choices made when it was designed. Understanding the reasoning behind those choices helps developers grasp the framework's boundaries more accurately, work with it more naturally, and get more out of it.

LinaPro's design principles revolve around five core themes:

• AI-Native Design: Treating AI as the primary engine of engineering productivity — not a supplementary tool. The AI-native design manifests in two independent dimensions: a spec-driven development workflow that lets AI participate deeply at every stage from requirements analysis to implementation and testing; and a built-in AI skill system covering the full development lifecycle, enabling AI to make framework-aware decisions in every specific work context — from backend development and frontend design to test coverage, performance audits, and version upgrades. Together, these two dimensions form LinaPro's core productivity engine.

• Modular Design: Every capability in the framework exists as a decoupled module that interacts with others through stable interfaces. Developers assemble systems like connecting building blocks rather than building from scratch each time — a fundamentally better way to deliver reliably at speed.

• AI Spec-Driven Development: Built on the principle that specs come before code, the spec-driven workflow captures every iteration's design decisions and implementation context as persistent documents, ensuring code, documentation, and tests are produced in the same iteration cycle — preventing architectural drift at the root. OpenSpec is the recommended tool for implementing this workflow.

• AI Engineering Quality Assurance: A systematic look at the engineering management challenges that emerge when AI becomes part of software development, and how LinaPro builds a complete quality assurance system across four dimensions: the SDD spec-driven workflow, full project-level specifications, interface abstraction with anti-leakage contracts, and high-density test coverage, where test code accounts for 39% of the total codebase.

• Framework and Plugin Capability Boundaries: Describes the division of responsibilities between the core framework and plugins — the core framework focuses on lightweight foundational capabilities and stable extension interfaces, while business capabilities are delivered through plugin extensions. Details how source plugins integrate through the pluginhost contract, dynamic plugins communicate through the pluginbridge sandbox, and the conventions governing route namespaces, public asset hosting, and admin workspace integration.

Related Documents

📄️AI Native

what AI-native truly means, how it differs from AI-assisted development, how AI participates in every stage of the development lifecycle, the built-in AI skill system covering backend, frontend, testing, performance auditing, and version management, progressive project specification management, and why spec-driven development prevents architectural drift over time.

📄️Modular Design

how the leanness principle (keep the core minimal, extend through plugins), domain-bounded built-in capabilities, a first-class plugin system, stable extension interfaces, and real-world examples like cloud storage and LDAP/OIDC authentication let developers assemble systems from proven building blocks rather than building everything from scratch.

📄️Spec Driven Development

the five-stage development loop (explore, propose, implement, review, archive), the responsibilities of AI and humans at each stage, the OpenSpec directory structure and spec file formats, and how spec anchors and mandatory E2E tests prevent architectural drift.

📄️AI Engineering Quality

the engineering management challenges that arise when AI is introduced into software development, and how LinaPro builds a complete AI engineering quality assurance system through the SDD spec-driven workflow, two layers of project specifications, interface abstraction and anti-leakage API contracts, and high-density test coverage where test code accounts for 39% of the total codebase.

📄️Capability Boundary

Capability boundaries between the core framework and plugins. It covers the default admin workspace, core framework control-plane APIs, the unified plugin API namespace, public plugin asset hosting, source-plugin HTTP routes, and the division of responsibility between source plugins and dynamic plugins. It also explains how APIPrefix, route contracts, public_assets, source, mount, and index are implemented across source plugins and dynamic plugins, so developers can understand exactly how the core framework and plugins collaborate without leaking responsibilities into each other.