Building blocks as the new unit of software

There's a quiet shift happening in how software is shaped.

For twenty years, the unit of software has been the file — a JS module, a React component, a Python class. Files are great for humans who want to read code top to bottom. They are terrible for language models trying to compose a system.

The new unit is the block.

What a block actually is

A Turbofy block is three things bundled together:

• A typed schema for what it consumes (data, config, copies).
• A self-contained runtime — usually a React component, sometimes pure server logic.
• A set of contracts about what it renders and how it reads data.

It's not a component. A component is a render function. A block is a contract about render and data and configuration. Same way a service used to be a contract about an API endpoint plus its database.

Why this matters for AI-generated software

LLMs are great at filling in a known shape. They are bad at inventing scaffolding.

Give a model a blank file and "build a dashboard", and you get a dashboard that imports six libraries you've never installed, three of which don't exist. Give a model a typed block contract — inputs, config, copies — and ask it to fill in the body, and you get something that actually drops into your app.

The block is the shape the model can reason about. The file is the shape the human used to need.

Three properties that make blocks durable

1. They compose without merging. Two blocks on the same page do not collide on global state because there is no global state — each block lives in its own iframe with its own runtime.
2. They survive refactors. A block's contract changes more slowly than its implementation. You can swap the runtime entirely and the page above it doesn't notice.
3. They are inspectable. Because the contract is data, an agent (human or AI) can list every block on a page, ask what data it consumes, ask what copies it expects — and reason about the whole system without reading source.

The trade you make

Blocks are slightly more verbose than "just a component". You define a record, you set defaults, you write copies. That's the cost.

What you get back: a system where every piece is independently addressable, replaceable, and editable — by you, by your team, by an agent.

When the unit of software becomes a thing a model can hold in its head, the cost of software changes. That's what we're betting on.