S01E04 · Working with AI Harnesses: MEGA lesson video by Theo Browne
Theo Browne explains how to separate the interface and workflow from an AI coding harness so switching models or harnesses causes less disruption. He demonstrates organizing skills and configuration across tools and machines with his Fleet repository.
videoTheo Browne · hq.mega.dev · Saved Nov 19, 2026
mega course, company harness, coding agents, agent skills, claude code
Transcript of the lesson video for S01E04 of the MEGA.dev course, by Theo Browne. Agenda: Harnesses · Interfaces · Settings · Workflows · Teamwork · Product. The video plays on the lesson page in MEGA Student HQ (needs a login).
0:02 [instrumental music] Time to talk about the thing that I've been dancing around for all the lessons so far, the harness itself. This is the layer that allows your LLM that is effectively just generating text to actually do things in your systems. When we did the simple demo earlier with the bash tool call, it was the start of a harness, but obviously, modern harnesses are way more complex than that, offering functionality that goes far beyond writing bash calls. Modern harnesses have fancy memory systems built in. They have tools that allow them to spawn additional sub-agents or their own threads, or sometimes complex workflows where they have multiple steps that agents run through independently. They have their own tools for editing files, reading files, updating data through MCP calls, and a whole of these other things.
There are a ton of different harnesses that have tons of different capabilities, and I could spend a lot of time going through all of that, but the harsh reality is that by the time this video's out, they probably will have changed meaningfully. So I'm gonna once again skirt around all of this and teach you durable skills instead. So we're gonna ignore that top because we're talking about how to not get trapped by your harness, a much more important thing. Tell me if you've been there before. You finally start getting really deep into Cursor. You've set up all the rules. You have everything in a state you like. You're making changes to your code pretty effectively, and then Claude Code drops, and everybody swears by it.
Or maybe you've already made the switch over to Claude Code, and you're getting pretty familiar, but your bill's going up a bunch, and you just heard that the new OpenAI model's really good, and it's way cheaper to run, so your workplace is trying to push you to switch over to Codex. But you just set everything up for Claude Code. You're screwed now, right? Well, in some ways, yes. It's a lot easier to change models than it is to change harnesses, unless, of course, the model is being provided subsidized but exclusively through one harness. Anthropic is Anthropic. They'll be how they are. But ideally, you should be able to switch between these things without feeling too much friction.
Not to self-plug too hard, but I love Michael's commentary here. If you're not familiar with him, he's the creator of Effect, which is a really popular way to make your TypeScript scale better. He posted recently saying that since he started using T3 Code, he no longer cares what harness is being used. He'd actually like to get rid of all of them. This is the thing that you should strive towards. You should not really feel the harness while you work. Fixating on which harness you're using, to me, feels similar to fixating really deeply on which code editor you're using, but it's even less useful and less productive than in those cases. Generally speaking, the labs are now training their models on their harness through their real-world histories, so most of the major releases, like from Claude and OpenAI, are gonna behave best in Claude Code and Codex respectively.
Generally speaking, if you're leaving those, you should have good reasons for it, but you also shouldn't care too much in general. I find people, myself included, get way too fixated on using whatever harness is coolest and hottest right now. What matters much more is that you're taking the most advantage of the tools you are using today in building skills, not like the Markdown files, but the actual skills around working with AI that will be durable across these different solutions. There's a lot of things that go into the harness. You have the UI that is exposing the capabilities of the harness. This could be a nice desktop app like the Codex app or the Claude Code desktop app, or it could be a terminal UI like an open code in the terminal or the Claude command.
And to the user, which is, believe it or not, you, sits in front and sends things and interfaces through the UI, which interfaces to the harness, which then goes off and hits the APIs for whatever models you are using, and then that generates tokens that get sent back to the harness. And if the tokens match certain patterns, it triggers certain behaviors, and then eventually, it spits those outputs into the UI that you read and then make decisions around. But there are other things that go into the harness, capabilities, knowledge, connections, and more. Like, maybe you have an MCP server that is connected to this, and now the harness has to inform the APIs and the LLMs of this MCP's capabilities and that it's available.
Maybe you have something that automatically runs a git status command right before it hits up the API so that the model knows immediately what is going on. This is why I had that silly thing in the last lesson where the model was aware of the files I deleted. That was my mistake because I'd forgotten Claude Code loves to include the git status in whatever s- thing it sends as soon as you start a new thread. The problem that I see a lot is that people think of the harness not as this little box that everything connects to. They think of it like this, this whole thing, all of the commands it can run, all of the stuff built into the system prompt, the MCPs that you're connecting to, the skills that you wrote that it has access to, the UI that you're using it through.
They see all of this as the same, and I don't blame them for thinking that way 'cause that's what the labs want. Anthropic and OpenAI really want you to think that this is Claude or Codex or whatever else, because then you'll get locked in and never leave the thing that you're using. But similar to what Michael said on Twitter, I don't even feel or notice the harness at this point because I work in a different UI layer. Personally, I'm using T3 Code. There's plenty of others too, like Herder, Human Layer, Orca, and more. Obviously, I like my own, and it's open source, so you can change it however you want. But there's tons of different options for how you will interface with the harnesses.
And then when you switch from one harness to another, less of your workflow will break. Personally, I think one of the first things you should do is yank that UI layer away from the harness. If you continuously tie yourself to the specific way of working that the harness has, then you're gonna be screwed the next time the best model switches from one lab to another. Right now, as the time of filming, there is no question that the best models are currently coming from Anthropic if you're working on code, but that could change at any point. And when it does, if you're all built around Claude Code and you wanna move over to Codex, you're gonna have to relearn everything from your key bindings to where you should put your skills to how the model behaves when it connects to things or does computer use.
So the more you can abstract the layer that you interface with, the less scary it is when a new model drops. This gets particularly dangerous once you start customizing the harness. I've seen people do some crazy things with Claude Code, building it up into this big, beautiful, chaotic machine that has endless capabilities. Every time I see them do that, it ends up burning them some amount. For example, Matt Pocock went all in customizing Claude Code to make it everything he wanted and more, and then Anthropic put out Claude bots that even further extended your customization. He has since almost entirely moved away because he's so frustrated with the way that Claude Code subscriptions don't have clear terms for where you can and can't use those tokens, and he doesn't know what and how to build around Claude because of how weird Anthropic's been with those same terms.
Obviously, open source solutions are going to be less, uh, risky in this way, but generally, you should try to build in ways that aren't so tied to a specific harness and its features. If you're okay with throwing it all away, it's totally fine and actually quite fun. I love building weird hacks into Claude Code, Codex, Py, whatever else I'm using at any given time. But I have found that I'm way more productive when I do as little of that as possible. I switch to a UI or application that I'm very familiar with using and have all my key binds, all of my skills, all of the things I rely on for my workflow there and ready to go.
And from that point, I just kind of fire things off and can get a good gut feel really fast as to what tools I do and don't like, because I have a flow that works well. And in the end, we're just sending text to these things anyways. We're writing prose in English for what we want, and we're hoping that the model has access to the tools and knowledge it needs to make the right result. Similar to what I was pushing on the last lesson, your goal shouldn't be to make sure your environment has every single thing you could ever need before you send your first prompt. You should hit the ground running. Try to use these things and get work done with them, and as you run into problems, that's when you should start making adjustments.
Ideally, you should make those adjustments in ways that are easy to reproduce other places. One of the things agents are great at is recreating and rewriting stuff in different shapes. If you have skills that are formatted in a way that only Cursor likes, or maybe you have some old Cursor rule files that you wanna port over, you can tell your agent to do that. They do need somewhere where it all lives. Everybody has their own strategies for this. I quite like mine, so I'm going to show that to you. This is a real repo that I maintain actively called Fleet. I have it called Fleet because it manages all of my skills, my config, my MCPs, and everything across all of my machines, and I have a lot of them now.
I have, like, 16 computers that I'm using for my agent work on a given day, and I pass things around to the different boxes depending on what I'm working on. I've started working on automatically hitting the right box for the right thing, but, uh, that's a lesson for another time, just some fun stuff I'm experimenting with. What we're here for is to see how I'm organizing things. And I wanna be clear, I don't actually open this folder up a whole lot outside of going to make changes to the prose in my skills and Markdown files, because that's where a lot of the value I can bring here is. The rest is just the general management.
So, I have here skills as a folder, and I have different subfolders for ones that I only want in Claude. Why would I have skills I only want in Claude? That's because I had a few skills in here that I only wanted to have used when I was using Claude, because they were teaching Claude how to call Codex. These ones actually don't exist anymore, so I can delete those folders. As you can tell, I don't spend a lot of time here. But the Anthropic front-end design skill is one that works really well with Anthropic's models that I have found doesn't work great with others, so I put it in this folder, and I have a metadata field here for the harness where I say only Claude.
And now, this skill will be on my Claude Code instances across my fleet. I then have a universal folder for all of the skills I want in multiple different places. So, this one, full send, I use multiple times a day. This is the skill I invoke when I know the model can complete the task, and I don't wanna have to see it again. I just want it to go merge the change. And here, I specify that the harnesses I want it to be in are Claude, Codex, Anti-Gravity, and Muse. And I want this on both my Macs, which is Darwin, and on my Linux machines, 'cause I do have some skills that are only on my Macs and then some that are only on my Linux boxes.
How am I managing and configuring all of this? Great question. You can probably guess the answer if you know me particularly well. I open a new thread in the Fleet repo, and I tell it what I changed or what I want, and then it does it. If I make a new skill, I tell it I made a new skill, it will commit it, push it up to the repo, and then push it to all the right places across the fleet. I didn't write any custom scripts to do this for me. I don't even know if there are any right now. I vaguely recall at one point that Astra wrote a script to automate this process of distributing my skills and config across my fleet, but I'm not actually sure if it did.
I just think it did. I don't care, though, because when I tell it I want this skill on all the machines, it just does it. And when I get a new machine, I open up this project and I say, "Configure the new machine based on what I have here." And this isn't just for configuring my harness and giving it all the skills it needs. This goes as far as describing how I like to use my computers, what tools they should have installed on them, how Tailscale should be configured, how to identify given machines, the color coding systems that are built for it. All these things are just files in this project that I use as a reference point when I configure new tools.
But even then, when I try out something truly new, like I move over to Anti-Gravity 'cause I'm trying out the new Google model, I will start without any of this initially, just to see how it works vanilla. And then, after I've got an idea for how it works by itself, I then tell Claude or Codex to go through this repo and configure everything the way I'm used to. I then try that out for a bit, I figure out the gaps between what I liked before and what I like now, and then I micro-adjust accordingly until I land somewhere I like. That said, I do have some workflows that I really like using right now, so I've encoded those as skills, and as soon as I'm working on a machine or a harness that doesn't have them, I usually go pretty mad, and I'll just tell it to copy them over.
All of this combined has made me feel pretty much entirely harness agnostic. I was able to move over fully from Claude Code to Muse in, like, three minutes, not even, and barely noticed the difference in terms of how it behaved and what it had access to. And at that point, I'm effectively just evaluating the model. The harness you're using barely matters outside of the system prompt at this point, and I found that adjusting that will have a much bigger impact in your day-to-day experience than changing which tools are available to the model. I find that if you get too deep in one specific harness, you're gonna lose out on a lot of the things that make all of this stuff really cool.
Think about the composition of your team at work. Imagine if you took the best engineer and you cloned them five times. How much more code can you write? Probably a lot. But how much better are your code reviews gonna get? Probably not that much, because if five people think the exact same way, they're gonna come to the exact same conclusions. Ideally, the tools you're using will let you hop between different brains, so different models, different agents, different harnesses, different whatever. And this is one of the things that I'm really proud of in T3 Code. We allow for your agents to call other harnesses. So, here we can see that this run I'm doing with Opus 5.
5 is also able to call Muse for writing code sometimes, and it's even calling GPT-61 Soul in Codex to get feedback on the work that it's doing. I find that this is useful even if a smart model's asking for feedback from a dumber one, because the dumber model might think about things slightly differently and find things that the smarter model missed. And if I was all in on Claude Code, I wouldn't be able to do this. In fact, when I was all in on Claude Code, I had a bunch of modifications in it so that I could use OpenAI models in my Claude Code. If you are curious, I still have this set up, and I can, in Claude Code- ...
call my Codex models. I did this for a while, but I found that the Codex models behave best in Codex, and the Claude models behave best in Claude. So I now have a solution that lets me use Claude models with Claude and Codex models with Codex without the friction of them not being able to interface. I used to have them generate Markdown files or HTML pages so I could link the context between the two, and that ended up becoming my job for a while. It's effectively just passing the context from one agent to another, putting it in my code review tools or wherever else it needs to go so that I could get the best out of all of these different things.
But then I have tools like Macroscope, Greptile, and CodeRabbit reviewing PRs. You're getting one layer of feedback there that prevents agents from making dumb mistakes. And now, inside of my actual daily driving ADE, which is T3 Code, I'm able to get additional feedback from other families of models and other harnesses without having to change how I work. When a new model comes out, it's just another thing to click in my dropdown. It's not a whole new world to learn. It's not like switching frameworks from React to Svelte or from Svelte to Angular. It's more like switching a CSS class. You're just changing over from one flavor of LLMs to another, and the harness starts to evaporate once you think about it this way.
What's going on now is effectively another level of abstraction. Similar to how back in the day we would abstract from the binary code that our computers were running up to low-level languages that were much more writable by humans, up to run times that would allow for even simpler languages to be built on top. That type of abstracting more and more as things evolve is going on rapidly right now. So of course, at the bottom, we have code, but above that, we had LLMs that could start writing the code, usually through autocomplete when you were typing in your editor. Maybe you would select some text command, K, and say, "Change this thing," and it would.
But we keep abstracting on top. Eventually, harnesses happened, and the role of the harness was to give the LLMs access to more things that you could then trust it to do more work through a UI layer, like a terminal with Claude Code or with T3 Code, whatever else. It is very likely we're going to abstract again. I would be surprised if most of us haven't moved to an assistant layer of some form on top over the next few months to few years, where instead of managing every thread yourself, you're talking to a higher-level agent that commands the threads for you. And this is also why I get so concerned about people obsessing over any one of these layers.
We've mostly gotten over our obsession with, like, the specific framework we're using, the specific syntax we're writing, fighting over tabs versus spaces, those types of things. That's what we would fight about here. We were in the LLMs doing the stuff era. We were fighting a lot about which rules to use, which model to use, what reasoning efforts and temperatures. Like, I still remember the era where everybody was complaining that we didn't have temperature controls in T3 Chat. This all seemed so important at the time, but I could tell it wasn't, because I knew the labs would get to the point where the defaults were right, and we didn't have to tune those knobs anymore.
Now I see the same with harnesses. Everybody who used to care too much about what temperature was set on their models now cares way too much about which tools are available in their harness. I was talking to somebody at an event yesterday that was trying to make a startup to help your agents pick the right tool. I have bad news for you. The agents are gonna pick the right tool, and if they didn't, it's because your tool description sucked. Stop over-optimizing at this layer. The harness should be as easy to swap out as the model you're using is. And if you are super deep on your one specific harness, you're gonna be screwed when we have another abstraction and we move to assistants that are calling our harnesses for us.
I've only just started playing with this in T3 Code, and it's kind of mind-boggling what it enables. I know a few people that have used T3 Code way more than me, that have done so much more work, and it had tens of thousands of threads that did all of it through one iMessage chat with Instinct, commanding the app remotely for them. And the more effort you put into super customizing the harness, the less prepared you will be when we abstract again. So generally speaking, what you want to do is make the work that your agents are doing as easy to understand as possible for the agent, regardless of what tool they're in. This could be your agent in Claude MD, but ideally, it's the code base itself, as I showed before, describing to people, and more importantly to agents, where things are so that they go to the right place first.
There's a trick I learned with ADHD a long time ago from Adam Savage that has fundamentally changed my life. When you are trying to find something in your house and it's not where you expect it, and then you go hunt and hunt until you find where it actually is, there's a place it belongs. It's wherever you checked first. Always put the thing back where you checked first. This applies tenfold to LLMs. If you make it so the obvious easy thing it does is right, you're gonna succeed. If you add hundreds of fancy tools to the harness layer so that the model is checking 500 times all these fancy things you built into it, if the code is right or not, you're never gonna figure out what the model's doing wrong, and you're also probably just gonna overwhelm it with choices that don't actually make sense.
And the most important thing to understand about these abstractions is that when we move up a layer, the layer below becomes much easier to swap out. When we were living in code, changing frameworks was miserable, but now that we've abstracted as much as we have, LLMs can rewrite a code base in a different language, much less a different framework, trivially. And then once the harnesses got really good, we got to the point where we can swap out the model and still get good performance, even if it's a different harness model pairing than is normally expected. And once we're in assistants, we're just not gonna be thinking about this anymore. And the more abstracted we get, the less the layer that we were in prior matters.
So, so the conclusion on my lesson about harnesses is to stop thinking so much about them and build in a way where the harness you're using doesn't feel so important, and the way you're working is what matters most. And that's why I'm really excited for my last lesson, workflows, where I'm gonna show you how I actually take the ways I like to work and teach the models how to do it so that I can be more effective in how I want to deliver software. [static noise]