November 18, 2026
Development is leaving the laptop
These are exciting times in our industry, and challenging ones. For the first time in many years, we have to go back to first principles and question solutions we took for granted. Most of them were designed around an assumption: a certain volume of code, pushed by a certain number of people. That assumption is breaking.
Saving on CI is the wrong fight
I keep hearing "my CI costs are going up, and that's expected." Trying to reduce those costs is the wrong approach. There is a ceiling on what optimization can buy you, and the code volume will keep growing regardless. More code means more to validate. You can squeeze out a lot today, but that's all you get. What's needed is a rethink of how we operate.
Concepts, not buzzwords
So what does the new way of working look like? There's a group of people pushing the "software factory" idea, where everything is automated and every piece gets an abstract name. It doesn't click with me. It's a pitch that works on companies like Siemens, which are famous for layers of bureaucracy and an appetite for looking modern. It makes for a great pitch deck, and probably an exit, but not much else.
I don't think we need something that abstract. We need to take one concept at a time and imagine how it would look. At Tuist, we've started doing that, first for ourselves, because we want to move fast. These days, speed is how you compete.
Some companies compete with capital: buying machines, paying people to talk about them, or giving free compute to open source projects in the hope of attention. We can't play that card, and we won't. We'd rather compete on innovation and on bringing something unique to the space.
The advantage of a vertical
We've built a vertical where we control every layer. That lets us design solutions at the level of detail and polish we want. For example, we run bare-metal Mac minis in our own infrastructure, which means we can design the rack itself to make things faster.
With these ingredients, we started exploring how development might evolve. Here are some ideas already in place.
Development is no longer tied to a machine
Coding harnesses already loosened the dependence on an editor. "You no longer need an editor, you need a harness" was a great shift, and the tie is looser every day. The next step is to decouple where the work happens from where the work is done. Any solution that steps into this space has to provide the compute, either yours or rented. In our case it's our own, optimized for the workflows we expect developers to run.
I'm writing this post by transcribing ideas right after coming back from the gym. While I was there, I continued work I'd started the day before and dumped new ideas as they came. I take the iPhone out of my pocket, press a button, dump the idea, put it back, and continue my squat. You have to experience it to feel how work is going to change.
I think of it as development becoming fluid. It starts at the gym and continues at the office. It starts with a colleague and loops in a designer, or the designer starts the job and passes it to engineers, reversing the usual flow. That's beautiful, and also dangerous, because limits get harder to draw. We went from the office to the laptop. Now it's anywhere, including your phone.
Many developers still say they look at their code, and today I sometimes do too, but that will happen less and less. There are things I still try on desktop, but I can initiate nearly everything from my phone.
More people can be builders
This may hurt some developers to hear, but the world needs more builders. Asmit on our team has cool, ambitious ideas, and he should be building features inside the app. My wife builds dashboards and contributes at her employer, work that needs code, and she should feel like a builder too.
A designer isn't going to make a Kubernetes change, but a small feature or improvement is well within reach. We should design environments where these people feel welcome, instead of expecting them to adapt to ours. That means treating some things as implementation detail.
PRs and code become implementation detail
I think pull requests will go away. Looking at code will go away. Code itself becomes an implementation detail that developers can hop into when they want to. We'll push straight to main.
That requires the UI to be designed for this. Deployment becomes: you ship, and something in the system tries to get it into production. If it doesn't go through, or something is detected, the change is ejected and a developer is looped into the conversation to understand what happened. We need a kind of continuous deployment ejection.
Observability that keeps up
Pushing to main needs much better observability. And it can't depend on a static list of dashboards and alerts. With this volume of code, they'd go stale almost immediately and lose their value.
We need something more dynamic, connected to a feature flagging system and the deployment pipeline, so agents can monitor, revert and toggle changes. It all has to be connected. The agent should know what's being deployed, know how to enable and disable things, and be able to observe the health of the system.
What we're building
That's the environment that needs to exist. Tuist is still an internal thing for now. We're building on the foundation we have, and we're almost at the point where we can code on the go, with voice. Because we started with native mobile and Swift, we can take advantage of most of the platform's features.