AI makes it easier to create but doesn't make it necessarily easier to control the outcome. Abstractions are still important, maybe more now than ever. As with any sudden change, there's a lot of dust in the air and it's hard to know where it will settle. It's important to look into what principles seem to be true independently of the change. Good software (and creations in general) will continue being [a collection of good (or interesting) decisions](https://diogosnows.substack.com/p/good-software-is-a-collection-of), who's making those decisions is hard to tell. It's possible any purely utilitarian application will be fully automated, especially if decisions can be objectively evaluated for quality, but customers want more than just execution. There's trust, beauty (yes, it counts) and judgement, these are hard to fully replace, especially since the definition of good in this space may not be objective. If you don't believe me, explain why aren't we still creating pages with basic old-school HTML and media elements? Applications are developed hierarchically, some decisions influence the space of other decisions you have to or can make, this is why abstractions are useful. It's useful to create internal interfaces that allow changes without a cascading effect. There isn't a single right abstraction set. The choice of abstractions is context dependent, it depends on the (predicted) intention for what's being built. The best abstractions can enable an exponential increase in the quality of downstream decisions. This is where human judgement comes (for now). If I had to guess, it's those who are best at aligning their decisions, principles and abstractions between human and machine that will produce vastly better outputs than others. Engineers are used to thinking in systems and abstractions, that can be an advantage, but it can also be a hindrance, as most of those abstractions are inadequate today. The mindset is more important than the experience of breaking specific types of problems down. ### Better tooling  I like Theo's video! Theo claims engineers are bad at prompting because they default to building custom software features for tasks they could just ask an AI agent to handle. Engineers should instead focus on building the underlying primitives and data pipes that allow agents to do more. I think the direction is good. **The issue with current engineering is over-defining at the wrong abstraction layer.** We should treat [[Harnesses are compilers|LLMs like a compiler]], the abstractions move to a different layer. Building a game with the scale of Assassin's Creed or GTA requires an unreasonable amount of these systems and abstractions. One of the best advantages of AI is being able to create better and custom tooling, Just-In-Time Tooling. Good tooling works best when there are clear systems and data models it operates on, even if these days there's an AI layer in between unstructured data and tooling. I would also argue it will soon be possible for a small group to reach the level of creation close to Assassin’s Creed (at least on the engineering side, content I’m not convinced yet). Actually, I'm going further, it might be desirable to build as a small group! **If the success comes from an exceptional sequence of good decisions, small groups can make them faster and more aligned.**