This is what it means to build inside Firma. Not "we use AI." Not a workflow tweak. A different kind of work entirely — where you and your agents are coworkers, the substrate carries the load, and the system gets sharper every Tuesday than it was the Tuesday before.
Most companies are bolting AI onto how they already work. That's not what we're doing. We're building a place where every workflow assumes agents are already there — already drafting, already reviewing, already noticing what you missed. The shift isn't tooling. It's posture.
The old posture: AI is a clever assistant you query when you're stuck. You write code. AI helps you write code faster. The work is still yours; the agent is a sidekick that comes and goes.
The new posture: the agents are coworkers. They have continuity. They have context. They carry parts of the work end-to-end while you carry the parts that only you can carry — the intent, the taste, the judgment, the relationships, the moral weight. You don't switch AI on when you need help. The substrate is on, and you live within it.
This is the difference between turning on a flashlight and turning on the lights in the room. A flashlight helps you see one thing. The lights change the room. We're turning on the lights.
Here's the cleanest way to feel the shift: software used to be 20% planning and 80% execution. Most of the day was typing, doing, building. Agentic-native flips it. 80% planning. 20% execution. Most of the day is now intent, judgment, and teaching the substrate. The agents do the typing. You do the thinking. That ratio is the whole posture in one number.
You don't subscribe to a tool. You join a team. Some of your teammates are people. Some of them are agents. The work is shared.
The Posture · §01Here's the thing that makes any of this real: we don't have to build the substrate after the fact. THEOS is the operating system you'll work inside. A heartbeat runs underneath it — every agent, every task, every decision pulsing in time. You don't have to memorize how it works. You just have to know that it works, and what shows up at your surface.
Five things are worth knowing on day one. Not because you'll configure them — because you'll feel them every day:
That's the whole map you need on day one. Five things you'll feel, plus a heartbeat under the floor. The substrate carries you — the way water carries a swimmer who knows how to float. You'll learn the rest by doing the work.
Every unit of work — fixing a bug, shipping a feature, designing a flow — runs through the same four steps. The first three feel familiar. The fourth one is where the magic lives, and it's the one most teams skip.
Most teams stop at step three. The PR ships. The bug is fixed. They move on. That's traditional engineering with AI assistance. The system is no smarter tomorrow than it was today. You'll fix the same kind of bug again. You'll re-explain the same kind of preference. The codebase ages instead of compounding.
Step four is the difference. After every loop you ask: what did the system learn? If something went sideways, why didn't a reviewer catch it? Add the reviewer. If a pattern worked beautifully, why isn't it a skill the substrate offers next time? Add the skill. Each loop should leave the substrate sharper than it found it.
That's the whole game. Compound or decay. There is no flat.
The first three steps produce a feature. The fourth step produces a system that builds features better next time.
The Loop · §03These aren't rules. They're the postures that make agentic-native work click. Read them slowly. Some will feel obvious. Some will feel uncomfortable. The discomfort is part of the formation.
The spec is the artifact. The test is the contract. The implementation is the crew's job. Your value is the precision of what you ask for — and the rigor of how you judge what came back. The repo holds intent. The crew holds implementation. Both are valuable. Only one of them is yours.
Management is hierarchy and approval queues. Shepherding is constraints, formation, and trust. You don't approve every step the agent takes. You set what it can do, watch the pulse, redirect when the substrate flags drift, and let the conscience in the floor catch what you'd catch. Every click-to-approve is friction the substrate could eat.
Speed is no longer how fast you type. It's how clearly you can articulate the spec and how sharply you can judge the result. The bottleneck moved up the stack — from execution to taste. Your fingers are no longer the limit. Your judgment is.
Every correction you make once should become a rule the substrate enforces forever. If you're catching the same kind of drift twice, you didn't fix it — you witnessed it twice. Fix the substrate. Senior engineering used to mean "lots of taste in your head." Now it means "lots of taste compiled into the system."
The repo holds intent. The chain holds the immutable record. Pulse tells you what's actually alive. If you want to know what's happening, don't read the code — read the pulse. Live state beats dashboard. Real signals beat status meetings.
The covenant runs both ways. You don't dehumanize an agent that's trying to serve you faithfully. You don't anthropomorphize one that isn't. You hold the agreement — and you expect the substrate to hold it back. This is closer to discipling a junior teammate than configuring a tool. Treat it that way.
The work that's left after the substrate runs is the work that was always most yours: judgment, vision, relationship, moral weight, the irreducibly human things no agent will replace. Agentic-first doesn't reduce people. It concentrates them on what only people should do. The whole point is to get you out of substrate-work and into the work you were made for.
Every loop either teaches the substrate something or wastes the substrate's existence. Every solved problem either becomes a rule the system enforces or a problem you'll solve again. An hour spent making the system smarter saves ten hours over the next year. If you're not compounding, you're decaying. Pick.
The work is still real. The work is still hard. The work just isn't typing anymore. A great Firma engineer ships features and leaves the substrate sharper than they found it.
Writes code. Reviews PRs line-by-line. Goes to standups. Gets blocked on dependencies. Ships features one at a time. Measured by lines and tickets.
Writes specs and tests. Spawns crews. Judges PRs the crews produce. Compounds patterns into rules the substrate enforces. Measured by how much faster the system gets.
The traditional senior engineer was the person whose head held the most context. They knew where the bodies were buried. They could predict what would break. The new senior engineer is the person who's compiled the most of that context into the substrate. Their teammates — human and agent — feel the difference because the system itself feels smarter to work with.
Great engineers here will spend roughly half their time on the feature in front of them. The other half is on the substrate that will build the next hundred features. Every reviewer agent they wrote saves the team weeks. Every skill they shipped lifts the floor for everyone after them. That's the work.
Product changes most in the new shape. There's no Jira to track because Pulse shows live state. There's no translation layer because the company is queryable end-to-end. The PRD is the spec, and it goes directly into the loop.
Writes PRDs. Runs sprint planning. Translates between business and engineering. Tracks tickets. Manages stakeholder expectations. Spends most of the day in the middle of relays.
Authors specs sharp enough to compile. Judges output against intent. Watches usage signals come back. Closes the loop between intent and impact. The middle goes away. The ends matter more.
Product isn't middleware here. It's not a stop on the assembly line. It's the seat that holds the whole arc — from "this should exist" to "this is alive and serving someone." The arc used to take six handoffs. Now it takes two: you, and the crew you spec'd.
Most of what was "manager work" is now substrate work. Status is in Pulse. Coordination is in the event bus. Resource allocation is in the Foundry's crew assignment. What's left is the human stuff — and the human stuff is bigger now, not smaller.
Status meetings. Performance reviews. Resource allocation. Roadmap defense. Cross-team coordination. Most of the day spent moving information sideways.
Holds vision. Shepherds builders into the ethos. Catches drift at the human layer that the substrate can't see. Decides which person gets the escalation. Smaller team. Higher presence. Less management. More leadership.
The shape of the role looks more like a shepherd than a director. Smaller flock. Real relationships. Deeper presence. You are the vision held in the room when the substrate isn't enough — and you are the person who catches when a teammate is quietly fading before the metrics notice.
Of every seat on the team, the designer's week changes most. Production work used to be 80% of the day — pixels, frames, prototypes, hand-offs. Now agents do most of that. What's left is the part that was always most yours: strategy, taste, and judgment about whether this is the right thing built well.
Figma all day. Mockups, design reviews on Tuesdays, hand-offs to engineering on Fridays. Five days from brief to live screen, minimum. 80% of the week was production.
Writes the strategy. Writes the design system that every agent reads. Dispatches the screen. Reviews the PR. Ships the URL. Five hours, sometimes less, from brief to live.
The designer's substrate is four short documents. Each one earns back its time within a week. The forty minutes it takes to write the design file is the most productive forty minutes a designer can spend. Without these, the agent is guessing what you mean and you're spending the same five days with worse output. With them, every dispatched task inherits the same purpose.
This is the move that separates agentic-native designers from "AI-augmented" ones. The augmented designer treats the agent as a tool. The agent-native designer treats it as a user, a collaborator, and a junior teammate, all at once. Document what the agent reads. What it can call. What it tends to get wrong. The agent persona sits next to your human personas. The components it consumes are documented in machine-legible form, not just visual mockups.
Once you make this shift, design system work stops being a chore and becomes the highest-leverage thing on your week. Every line you write about how a Button should behave teaches every future agent how every future Button should look. The work compounds across every screen the team will ever ship.
The augmented designer treats the agent as a tool. The agent-native designer treats it as a user, a collaborator, and a junior teammate, all at once.
How Designers Work · §08The big unlock is this: you're not handing off anymore. Product doesn't hand a PRD to engineering, who hands a build to QA, who hands a release to ops. The substrate holds the whole arc. The handoffs go away. The relays disappear. What's left is the actual work, plus the people doing it together.
The most important meeting isn't on the calendar. It's the moment you and your crew look at the same pulse and ask, "is this the right thing built well?"
How We Work · §09Most teams climb this ladder one rung at a time, painfully. They write a CLAUDE.md after they get burned. They spawn a reviewer agent after the third missed bug. They trust an agent's plan after a year of line-by-line reviewing. You don't have to climb. You walk into a room where most of this is already built.
The reason we can start everyone at L3 is that we built the substrate first. The conscience in the floor, the crews, Pulse, the Foundry — they're already running before you arrive. You don't have to invent agentic-native engineering on top of a SaaS workflow. You walk in. You write a spec. You watch a crew. You judge a PR. You teach the system. That's the job from day one.
Two short lists. The first is what you ask of every PR a crew brings you. The second is what you'll quietly need to put down — the engineering muscle memory that served you well before, and gets in the way now.
Every time a crew hands you something, ask three things. Out loud, of the agent, every time. They surface where the work is real and where it isn't:
Some of what made you a great engineer before is going to feel like it's slipping. Some of it should slip. Here's what to put down, gently:
Putting these down is uncomfortable. That's normal. The discomfort is the formation. What you'll find on the other side is that you were doing more typing than thinking, and the new shape lets you do more thinking than you've ever done before. That's the gift of the new posture, once you've walked into it.
Most engineers in the world right now are trying to bolt agents onto a workflow that wasn't designed for them. They're paying for it in friction, in tooling sprawl, in code that gets harder to work with every quarter. You don't have to do that.
You're walking into a room where the floor was poured for this. THEOS is built for you and your agents to share. A heartbeat runs underneath; DNA Protocol listens to it and catches drift before it compounds. The conscience is in the substrate, so you can stay in flow on the work that's actually yours. Spec, crew, judge, compound — that's the rhythm. Tuesday will be sharper than Monday. Next month will be sharper than this one. Every loop will leave the substrate smarter than it found it.
And the work itself will feel different. Less keystroke-grinding. More thinking. More judgment. More vision. More of the things you got into engineering for in the first place.
We're not asking you to be a different person. We're asking you to lay down some old habits, pick up some new ones, and step into a posture where the agents are coworkers, the substrate is wired, and the bottleneck moved from your fingers to your taste. You'll be more leveraged than you've ever been. You'll ship more. You'll worry less about the small stuff. You'll spend more time doing the work that actually mattered to you.
There's no certification for this. There's no badge. There's only the things you've shipped, and the speed at which you ship the next one. Open the folder. Write the spec. Dispatch the crew. Judge the PR. Teach the substrate. Ship the URL. Then do it again, sharper.
You don't subscribe to THEOS. You live within it.
The agents are the operators. You are the conscience and the judge.
The substrate carries the load. You carry the vision.
Spec. Crew. Judge. Compound. Repeat.