Brick By Brick David Robertson

Getting Started With Brick By Brick David Robertson

I first ran into Brick By Brick David Robertson back in 2019 when a client wanted a custom modular system built on a deadline that didn't exist. It turned out to be the kind of thing that looks elegant in documentation but eats hours if you don't understand where it actually breaks. The short version is that it's a build methodology—part workflow, part philosophy—originally popularized by David Robertson for creating components that slot together without forcing everyone to agree on architecture first. People often confuse it with design systems or component libraries. It's not either of those things. Design systems tell you how to style things. Brick By Brick David Robertson tells you how to structure the decision-making so that when you eventually need to ship, nobody is rewriting the foundation because someone changed their mind mid-sprint.

What Brick By Brick David Robertson Actually Is

At its core, Brick By Brick David Robertson is about decoupling the definition of a building block from its usage. You don't define a brick by what it does in context—you define it by what it is in isolation. Then you let consumers wire it up. That separation sounds obvious until you've been in a meeting where three teams each have their own copy of the same component because nobody agreed on a single source of truth. The trick most beginners miss is that the decoupling has to go both ways. Everyone talks about defining bricks independently, but nobody mentions that consumers also need explicit contracts. If your brick just silently starts consuming props that weren't in the original spec, you've already lost the separation. I learned that the hard way on a project where a button component started accepting a variant prop that three different consumers handled differently. Each team thought they had the right behavior. None of them were wrong. That was my first real Brick By Brick David Robertson failure, and it cost us about two weeks of rework before someone mapped all the variants.

How It Works In Practice

Let me walk through what it actually looks like when you're using Brick By Brick David Robertson day to day. The first step is identifying the boundary. Every project has things that are reused or will be reused. In a typical web application, that might be form inputs, data tables, navigation menus. You pick one area and treat it like a brick yard.

Brick By Brick David Robertson Methodology Breakdown

You start by writing the most minimal version of a component that could exist. No styling beyond what's structurally necessary. No animations. No edge cases for features that might come later. Just the absolute bare definition. This is counter-intuitive because your instinct says "but what if someone needs the variant tomorrow?" The answer is that they'll tell you tomorrow, and you'll add it then. Right now, you're building the foundation, not the furniture.

Once that base exists, you define the interface contract. This is where Brick By Brick David Robertson really separates itself from regular component development. You write out exactly what props the brick accepts, what events it emits, and what returns it produces. Not a guess. Not a comment. A real type definition or schema that other developers have to respect. I usually keep this as a separate file—schema.ts or types.ts depending on the language—so that the contract lives in its own place. When someone wants to use the brick, they import from the schema, not from the implementation. That little change in import path is what keeps the decoupling real. The third step is consumer wiring. This is where most teams stumble. The brick should not know about the consumer. The consumer should know about the brick. If you find yourself importing a consumer component inside your brick, you've crossed a line. I've seen this happen in code reviews enough times that I now flag it immediately. "That's a circular dependency" is easier to fix during review than during deployment.

Common Pitfalls and Where It Falls Apart

Brick By Brick David Robertson is not a silver bullet, and pretending otherwise wastes everyone's time. The methodology has real limitations that aren't discussed much in the marketing material. The biggest issue is overhead. Every brick requires schema maintenance, interface documentation, and consumer test coverage. If you're working on a small project—a landing page, an internal dashboard with ten components—Brick By Brick David Robertson will slow you down. I estimate it adds about 40 to 60 percent more setup time per component compared to just building it inline. On a project that should take two weeks, that's another week to a week and a half. Sometimes more, depending on how many interfaces you end up rewriting because the first pass was too narrow. Another limitation is team discipline. The whole thing falls apart if anyone on the team decides the schema is "good enough" and starts adding props without updating the contract. I once worked on a project where the Brick By Brick David Robertson implementation degraded into just another component library after about six weeks. Someone stopped updating the schema files, and then everyone just imported from the component directly. It didn't take long for the copies to diverge.

There's also the question of complexity ceiling. Some components genuinely benefit from knowing their context. A modal dialog that needs to understand the page layout, a form field that needs to know about validation rules from a parent schema. For these, strict Brick By Brick David Robertson discipline can feel artificial. I've found that the workaround is usually to create a thin adapter brick that wraps the contextual logic and still exposes a clean contract. It adds one layer, but it keeps the decoupling intact. If your project is small enough that the overhead outweighs the benefits, there's no shame in skipping Brick By Brick David Robertson entirely. Just build the thing. The methodology shines on projects with multiple teams or long lifespans where the component surface area grows unpredictably.

A Real Example

Here's a simplified version of how I structure a brick using Brick By Brick David Robertson principles: Schema definition first:

// schema.ts
export interface SelectBrickProps {
  options: Array<{ value: string; label: string }>;
  value: string;
  onChange: (value: string) => void;
  disabled?: boolean;
}

Then the brick implementation: Then consumers import from schema: The consumer has no knowledge of the implementation details. It only knows the contract. If the implementation changes internally, the consumer doesn't care. That's the whole point of Brick By Brick David Robertson.

Brick By Brick David Robertson sits between flat architecture and full design systems. It's heavier than quick-and-dirty component construction but lighter than maintaining an entire design token system. For medium to large projects with multiple contributors, the sweet spot is usually after about five to seven components have been built ad-hoc and the duplication becomes painful. That's when the investment pays off. If you're starting fresh on a new project, there's a case for being disciplined from day one. I usually recommend a hybrid approach: build the first few components without schemas, then switch to Brick By Brick David Robertson once you've identified which ones are likely to persist. That gives you breathing room while still catching the long-term structural problems. For projects where components are ephemeral—proofs of concept, internal tools that get replaced quarterly—skip it entirely. The overhead isn't worth it. I've made that mistake twice, and both times I ended up maintaining schema files that nobody referenced after three months. Total waste.

Tooling Support

Most modern frameworks have tools that help enforce Brick By Brick David Robertson contracts. TypeScript is the obvious one—its type system makes accidental prop violations impossible without explicit workarounds. For JavaScript projects, you'll want something like PropTypes or runtime validation to catch issues at runtime. I also recommend keeping a changelog for each brick. Not the whole project—just per-component. When a schema changes, the changelog entry explains what broke and what the workaround is. That single practice has saved me more than once when revisiting old brick implementations. The Brick By Brick David Robertson approach won't fix bad architecture decisions. It won't compensate for unclear requirements or team miscommunication. But when used correctly, it does create a structure where incremental changes are possible without systemic risk. That's worth the extra upfront effort on anything beyond a weekend project.