Engineering the organization
Marek and I engineered our operations around how we imagine ourselves working every day. This is Atlas, and this is why AI matters to us.
Writing
The dopamine of complexity
Humans love complex solutions because our dopamine wiring rewards them. Notes on Tobi's latest interview, dogma, and why Tuist chose simplicity.
Down to the metal
We are deploying our own Mac hardware in a data center, sooner than we planned, because renting it turned out to be neither transparent nor financially viable.
Language, not pixels
Building software is a lot of fun right now. More and more of it is becoming headless, and the value keeps moving from pixels to language.
Peeling the PaaS layer
We moved Tuist from PaaS solutions to Kubernetes, and coding agents turned out to be the layer that makes that complexity worth facing.
Conceptual compression in the age of coding agents
DHH's conceptual compression, coding agents, and why the complexity of tools like Bazel can be compressed in more than one way.
Publishing from the harness
My blog has always been a playground for technology. Here is how its publishing pipeline evolved from a static site and a CD pipeline into a small Elixir engine I can publish to straight from a coding harness over MCP, the project I now call Gesttalt.
Producing value is not capturing it
Developers are good at producing value and assume that capturing it should follow. Some observations on why it does not, and on what selling to developers actually rewards.
Building towards the non-obvious
On balancing the obvious with the non-obvious, and why we're building towards a reality where waiting on compilation and tests becomes intolerable.
Doing things once
There's something that has been bugging me since I started working more with coding agents: helping them close the loop effectively. This is the exploration behind Once, an automation substrate that lets agents understand the best way to validate their changes.
The user is not always a person
For as long as we have built SaaS, we assumed a human was the one registering, setting up, and wiring things together. That assumption is quietly breaking, and it changes how software should be designed.
We don't have time for that
On the people who feel great by making you feel small, the gravitational force of doubt around anyone building something, and why we moved on from one of those conversations today.
I could hear them beating
A running accident in 2024 injured my sciatic nerve and left me with foot drop. Two years, a nerve graft, and a year and a half of daily mental work later, an electromyography finally showed the brain's signals reaching the muscle again.
Distributed incrementality
Why productivity infrastructure suddenly matters for everyone, not just the giants. Local incrementality no longer holds once coding harnesses spin up parallel worktrees, and build systems need a redesign around distributed incrementality.
The remote development mirage
A post on X predicted that development would all move to remote sandboxes. Here is why I think that is a mirage, what makes the model attractive to executives and unappealing to developers, and where selling compute actually makes sense.
Closing for security
Daytona went closed source yesterday, and the reasoning was security. Look at these moves through the lens of business instead, and a different and more honest story shows up.
The quiet corner
Why we are betting on remote caching instead of compute, and building Kura and Once in the open as the quiet corner everyone else overlooked.
The cost of a fork
Every build system is a trade-off. The one that interests me is whether you stay native or fork the ecosystem, because a fork has a cost that doesn't go unnoticed.
The automation graph agents need
Coding agents can write the code. The harder part is closing the loop afterwards, and I think the missing piece is an automation graph that connects changes to the work, context, and people they imply.
Inside the container
Selectiveness is the real theme underneath monorepos and the agentic world: a graph of domains and tasks that tells your compute what to actually do.