Skip to main content
Version: 0.1.40 (Beta)

Thonnas

An AI-native framework for building production-grade software.

Thonnas gives AI the architecture, rules, and pre-built modules it needs to produce code that belongs in a production system -- not a prototype that falls apart under load.

What is missing from vibe coding​

AI code generation is powerful, but on its own it produces trailer-park home quality software. The code works in a demo. It does not work at scale, under security review, or when a second developer needs to understand it six months later and isn't designed to evolve and iterate.

The problem is not the AI. The problem is that the AI has no architecture to follow, no conventions to respect, and no tested building blocks to start from. Every feature is improvised from scratch. The result is inconsistent structure, duplicated logic, missing error handling, no observability, and security patterns that would not survive a penetration test. The community has started to address this by sharing language and role specific agents or rule files that provide general AI prompts that they hope improve the quality, but it is not enough. Each stage of the Software Development Lifecycle needs precise adjustments for every part of the software stack (web, mobile, backend, database, observability, reporting, etc).

Thonnas exists to close this gap. It provides the engineering scaffolding that turns AI from a fast typist into a disciplined builder to produce skyscraper quality software:

  • Component rules teach the AI your project's conventions, file structure, and coding patterns -- so generated code fits in, not sticks out
  • Strategy definitions give the AI a vocabulary of capabilities (authentication, caching, observability, messaging) so it makes architectural decisions, not just syntax decisions
  • A structured planning lifecycle forces requirements, architecture, and task breakdown to happen before code is written -- the same discipline that separates an engineered skyscraper from a structure that cannot pass inspection
  • Phased implementation with review loops means code is reviewed, verified, and refined automatically -- not shipped on the first attempt

The goal is not to slow AI down. The goal is to give it the point-in-lifecycle context it needs to produce production quality output at AI speed and scale.

Stop re-inventing solved problems​

Every time AI writes a login flow from scratch, it introduces unknown risk. The JWT token handling might be subtly wrong. The password hashing might use a deprecated algorithm. The session management might leak memory under concurrent load. And nobody will know until production.

These are solved problems. User authentication, role-based access control, CRUD operations, file uploads, payment processing, notification systems -- thousands of teams have built, tested, broken, and hardened these patterns. Why are we trusting AI to rewrite these solved use cases from zero every time?

The Thonnas Marketplace delivers pre-built modules for common use cases:

  • Human-tested -- modules are reviewed, not just generated
  • Vetted for security -- authentication, authorization, and data handling follow established standards
  • Performance benchmarked -- modules include load test results and resource consumption profiles
  • Cost transparent -- infrastructure cost implications are documented per module

Modules are not black-box libraries. They are installed inline into your source code via an AI-powered patch system, becoming part of your codebase. You own the code, you can read every line, and AI can customize it further for your specific needs. The module gives you a proven baseline; AI gives you the customization.

thonnas install tm-auth          # battle-tested auth with JWT, OAuth, password reset
thonnas install tm-user-count    # real-time user presence tracking
thonnas install tm-notifications # email, push, and in-app notification system

Each module is cross-functional -- a single install adds API endpoints, frontend components, database migrations, workflow definitions, and observability instrumentation across every component it touches.

Works with any AI, any language, any stack​

Thonnas is not locked to a single AI tool or programming language.

AI tools: Rules are authored once and the rulesync aggregator generates the right format for your IDE -- Cursor, Claude Code, GitHub Copilot, Windsurf, or any future tool that reads project-level rules.

Languages and frameworks: Components can be written in any language. The framework ships with NestJS, Angular, React, Flutter, PostgreSQL, MongoDB, Redis, and Temporal components, but the architecture supports any stack. A Go API, a Python ML pipeline, and a Swift iOS app can all be components in the same Thonnas project.

Infrastructure: Run locally with Docker Compose during development, deploy to AWS with CDK for production. The same thonnas-infra.json derivations resolve environment-specific values automatically.

Learn more​

Concepts​

Understand the building blocks:

  • Components -- the runtime units that make up your application (APIs, frontends, databases, infrastructure)
  • Modules -- cross-functional business features installed inline from the marketplace or built custom
  • Strategies -- named capabilities that enable decoupled, interchangeable implementations
  • Use Cases -- named business actions that connect code to requirements, testing, and observability

Get started​

  • Installation -- install the CLI and prerequisites
  • Quick Start -- scaffold and run a full-stack project in under 5 minutes
  • Workshop 1 -- build a real-time user-count feature from prompt to production