An aggressive first principles approach often leads otherwise well-intentioned technologists into strategic / ideological dead-ends.
Do we do things because it's the "right thing" to do in the moment, or because of the final outcome that will eventually result?
The most ideal answer is somewhere in the middle. I am far more interested in the total area under the curve than a single instant in time.
In lieu of intentional higher order thinking, simply working backward from your customer on a regular basis will generally accomplish the same outcomes.
They're not so much at odds, but the emphasis is very different and therefore the failure modes are. First principles thinking emphasizes the principles, and so that's why there's an ideological trap; all you need to justify a given direction is some rationale from first principles, and that's often good enough.
The problem is... which first principles? Say your goal is to get to the moon, and the principle you use is to minimize the distance, and you choose to do this in a greedy fashion. This will have you climbing ladders, trees, buildings, and mountains, but you haven't reasoned far back enough to figure out just greedily minimizing your distance to the moon is never going to get you there, no matter what. Choosing the wrong principles can lead to local extremes which can be a lot harder to see in cases less obvious than going to the moon.
I'm really struggling to see how to make architectural decisions with an agent. It's great when you're at a total loss for ideas, but when you already have some of the pieces it ultimately wants to drive all of the thinking and takes over. Then it just feels like you're deferring your experienced judgement. I've seen colleagues lose the ability to reason any more without asking the agent to do it for them, because they inherently don't see the point if the agent is going to end up doing the whole piece (and probably auditing/overruling anything they came up with on their own).
I tend to find this part of the work enjoyable. It is just a faster and more productive version of what I would do with any engineer working for me who owns a large feature. I barely have to hint at my concern or drop the right keyword and the agent (Fable/Astra) will immediately understand.
"Couldn't this be stateless?" "Do you have a plan to be able to shard this?" - We will almost always pivot from the agents initial design but the agent is able to easily understand the reasons and benefits and align quickly.
If I was writing the code myself, I'd often have to make compromises between the ideal architecture and the level of effort required to implement it - now I can just always have the ideal architecture.
Now you have what you think is the ideal architecture. Since you didn't implement it, you didn't discover it was not the ideal one mid way into the implementation.
May be it is too complicated, but you wouldn't know, because LLM is doing the implementation. If you did implement it yourself, you might have spotted a critical point that might simplify the whole thing...
Jodie Foster did make an amazing discovery that way in the movie Contact, that is true. "Why build one when you can have two at twice the price?" would be my engineering takeaway from that movie though.
> I'm really struggling to see how to make architectural decisions with an agent. It's great when you're at a total loss for ideas
I feel the opposite, like if I go to an agent without first knowing what I want to build, I'll never figure out what I'm doing or why and it'll run away from me.
I pretty much always go back and forth and have the agent write out a plan to a file and review it myself in my text editor. I still sometimes end up with surprises I disagree with, but I don't really find it to be true that the LLM ends up trying to "drive all of the thinking".
When I'm thinking through an architecture, I not only instruct it to refrain from writing any code, I don't even necessarily tell the agent what I'm trying to build.
> I'm really struggling to see how to make architectural decisions with an agent.
I walk to work and home with ChatGPT Voice and AirPods. I ask it to be Socratic and I just start rambling the top of thing on my mind. After 20 mins of back-and-forth it's usually teased an answer out of me or I've teased an answer out of it.
Sometimes it's easier for me to scaffold the architecture (in real, working code) and then let the agent fill in the implementation. And I make the agent document the architecture and have it refer to the documentation when coding. When I review agent code, I focus only on architecture (is it following existing architecture? is it introducing new structures, dependencies, etc.?)
Other times, I let the agent create a black box with a well-defined interface contract. I don't care about the architecture inside the black box.
This is one thing I actually do with a chatbot, instead of an agent. Voice mode even.
I start talking to it while doing menial tasks like cleaning or doing the laundry, and I discuss the architectual decisions and options until I come to some resemblance of a plan.
Good side of this approach is that I can't just "skim over" or "copy paste" things - either I understood them and can repeat them myself, or I can't. It takes more time than /grill-me and similar approaches, but it's the only approach that doesn't make me want to claw my brain out.
Why would you care about architecture? It was an issue when humans were writing code so architecture mattered in the sense that you needed a sweet spot between current requirements and future extensions.
The agent can rewrite half your codebase in one day, so architecture stops mattering for the most part.
Why try to make things that are good? Why care about anything? Why not just turn our minds over to the machines, and let them rock us to sleep like babies?
Possibly because the goal is the end product that serves a purpose and has value, not the process.
If you can make your product, make the customer happy, and make your money to enjoy your life and secure your families future… why care who or what or how (as long as it’s ethical obviously).
Every choice has a cost. The question comes as to when you pay it. Your idea of an end products behavior, and the end products behavior when it interacts with reality may differ significantly.
For example is unknowingly writing a security flaw ethical, when you could have used a set of processes to reduce them before release that would have make the entire thing take longer and cost more. Seems like programmers need a lot more ethics classes as ethics are part of any large scale process.
LLMs benefit from abstractions for the same reasons that humans do. More information in the same amount of text. Fewer working parts to juggle so fewer ways to make mistakes.
Mhh I've tried one-shotting double buffered IO a few times and it just can't do it. Maybe it's a prompting issue, maybe LLM's have a hard time with thinking about parallel processes.
I'll create a simple "framework" of what I know works. After that's there the LLM is fantastic.
Why would you care about architecture? Ability to implement the current feature, ability to implement future features, maintainability, and (at least sometimes) performance.
But why would you care when an AI can just rewrite it? Yes, but can it rewrite it to a good architecture? Or just to a different one?
Does a good architecture make code easier for an AI to maintain? I don't know, but I think it's at least not proven that it doesn't.
It’s important for separation of concerns, which is important for maintenance and future iteration on features and bug fixes. If you don’t have separation of concerns, every change to anything is essentially a from scratch rewrite of the whole thing. That’s also incredibly inefficient in token usage.
I have had really good experiences with designing architecture with agents. It is much much better than humans and frankly, if my colleagues had used agents to design their new services, we'd have been in much better place.
While I think there are better introductions to "first principles thinking" than this post, the idea of "...When I step back and ask what we’re actually trying to do, why it matters, and how the pieces connect, I usually find more ways forward than I expected."
That's an important skill to have.
However, I think sometimes we overvalue thinking from first principles when it isn't warranted. I've seen times in my career where first principles thinking led to a solution that ignored key non-technical constraints. (For example, it would require a full re-architecture of the system and require deferring all feature work for a year. Another example: the proposed solution breaks Conways law in a way that would require a reorg that would break other organizational constraints.)
Sometimes, we need to recognize our constraints. Spend the time to question them when appropriate, but realize that there are other tools that are more appropriate in some cases -- such as anthropological thinking.
> However, I think sometimes we overvalue thinking from first principles
The problem isn't the thinking though, but the lack of grounding.
You don't have a problem with people coming up with a technically better solution. Your problem is with the people not realizing that they exist in reality and not in a vacuum.
Please don't question the act of thinking itself. It is the wrong target.
From the blog he linked to: "I’m going to try designing something way more ambitious."
This is how you end up with unnecessary complexity [1]. The best engineers don't aim for "designing something ambitious", instead they come up with the simplest possible design. They take something that seems complex and make it simple.
Unfortunately that's not how engineers are evaluated [2].
"I am going to solve a complex problem" is a better goal. If you start with the goal of designing something ambitious then the design will likely end up more complex than necessary.
> When you truly understand what you’re trying to accomplish, it’s easier to take a small step...
I think they're describing an approach to decision-making in the context of agents.
Engineers encountering LLMs for the first time think the problems they encounter are entirely novel, but really we are rehashing old lessons which Fred Brooks wrote about half a century ago, but in new jargon.
The essential difficulty of specifying what you actually want remains the same and nothing I've seen from LLMs will change that.
Whatever it is you are doing, consider the very basic reason for doing it. And then, build your solutions from there from what is available. Examine the first principles of whatever it is you're doing.
You are working, and you are building things, to create value.
What are the tools you use to move about your environment and create your product, your value? Your knowledge, your training, your time.
If you examine the first principles of whatever it is you're doing, you should realize: you must keep your toolbox open and ready to swap new tools in and out in order to keep up with the time and manage yourself effectively.
AI is a tool, learn to use it as a tool and stop 'fighting the times' so much. All of your criticisms are valid, and you are correct: but everyone still wants to save time, and so you must keep up.
Very confusing indeed. Is the core idea to read the picture as a flow from left to right? Or some people go down and left, but you need to first go right and iterate. Then go left and put it in a box. and then... dunno, lost track of thought, did AI or someone who is very new to Consulting write this?
I've been using codex to design and build a product that is a fairly conventional looking app - think of a gmail like experience - with some delicate synchronization across devices.
I find that I need to invest a whole lot in high level design myself to get Codex to create a suitable architecture and make the right tradeoffs. It's more like I am designing and Codex is reviewing and occasionally we brainstorm. When I tried having it design based on requirements, it went wild with an unsustainable design / architecture.
And I use things like plan mode etc. My experience is unlike what I read in most vibe coding exploits.
I wonder if I am doing something wrong. Is there a good canonical example of a project built with Codex or even Claude Code that shows how the human and AI interact that I could use as a reference
I've been on a similar path, and I used to put time in high level design, as it was basically required in some cases. But not a lot of time, because smaller agents research, perform small tests, whatever to inform the high level design. Working incrementally seems to help, maybe prompting a bit more often, but the same can be accomplished with well defined checkpoints.
Then generalize + standardize that process, get an agent to replace you as high level designer so you can manage a team of high level designers, etc etc
This is one of those things where one can throw around the term "first principles thinking" with relative ease.
To actually do it is different and usually comes from having to wrestle with a problem.
Sadly people from the academia and the public at large has a hard time understanding what this even means.
They equate it with exam based memorization or delegation to authority. Funnily they even think first principles reasoning is an improved version of doing the same.
But this is a blessing in disguise as it gives those who wrestle with real problems a unique skillset that can be advantageous.
> Sadly people from the academia [...] equate [first principles thinking] with exam based memorization or delegation to authority.
In what departments and at what universities? The term "first principles" comes from academia. I think you'd be hard pressed to find a faculty member in any philosophy department doesn't understand what reasoning from first principles is. I'd be surprised if any working mathematician thinks of "memorization" or delegating to authority rather than axiomatization. What experiences led you to say this?
Its so ubiquitous, you can pick random folks from most academia and see it first hand.
If this comes as a shocker to you, then I should be the one to enquire as to how you managed to stay blind in the face of the obvious.
Just strike up a discussion on some complex topic, and you can see many people resort to "because the author here in this book said" or "we are taught so and so".
A first principles reasoning can show you the steps that lead to a specific conclusion without invoking any author, teacher or course.
And it's a skill that you'll use in other contexts. Over too learn and practice it in IT/physics, and you find out that you can use it to psychology, humans around you are dealt with another depth and different outcomes become possible
Higher order thinking is more important and rare.
An aggressive first principles approach often leads otherwise well-intentioned technologists into strategic / ideological dead-ends.
Do we do things because it's the "right thing" to do in the moment, or because of the final outcome that will eventually result?
The most ideal answer is somewhere in the middle. I am far more interested in the total area under the curve than a single instant in time.
In lieu of intentional higher order thinking, simply working backward from your customer on a regular basis will generally accomplish the same outcomes.
They don't seem at odds to me, just two ways of looking at a problem.
They're not so much at odds, but the emphasis is very different and therefore the failure modes are. First principles thinking emphasizes the principles, and so that's why there's an ideological trap; all you need to justify a given direction is some rationale from first principles, and that's often good enough.
The problem is... which first principles? Say your goal is to get to the moon, and the principle you use is to minimize the distance, and you choose to do this in a greedy fashion. This will have you climbing ladders, trees, buildings, and mountains, but you haven't reasoned far back enough to figure out just greedily minimizing your distance to the moon is never going to get you there, no matter what. Choosing the wrong principles can lead to local extremes which can be a lot harder to see in cases less obvious than going to the moon.
Reasoning backwards has its own traps as well.
I'm really struggling to see how to make architectural decisions with an agent. It's great when you're at a total loss for ideas, but when you already have some of the pieces it ultimately wants to drive all of the thinking and takes over. Then it just feels like you're deferring your experienced judgement. I've seen colleagues lose the ability to reason any more without asking the agent to do it for them, because they inherently don't see the point if the agent is going to end up doing the whole piece (and probably auditing/overruling anything they came up with on their own).
I tend to find this part of the work enjoyable. It is just a faster and more productive version of what I would do with any engineer working for me who owns a large feature. I barely have to hint at my concern or drop the right keyword and the agent (Fable/Astra) will immediately understand.
"Couldn't this be stateless?" "Do you have a plan to be able to shard this?" - We will almost always pivot from the agents initial design but the agent is able to easily understand the reasons and benefits and align quickly.
If I was writing the code myself, I'd often have to make compromises between the ideal architecture and the level of effort required to implement it - now I can just always have the ideal architecture.
> I can just always have the ideal architecture.
Now you have what you think is the ideal architecture. Since you didn't implement it, you didn't discover it was not the ideal one mid way into the implementation.
May be it is too complicated, but you wouldn't know, because LLM is doing the implementation. If you did implement it yourself, you might have spotted a critical point that might simplify the whole thing...
If you did implement it yourself, you might have spotted a critical point that might simplify the whole thing...
This is the "Jodie Foster in Contact listening for the SETI signal with headphones" theory of how production software systems work.
There have been multiple points in my career where I framed a problem as simple in my head, and it mostly was.
But then, one small detail changed everything. And it wasn't something I'd have thought of until I was writing the code.
I shudder thinking about the number of these issues hiding in LLM-generated code.
And yet, continuing your analogy, she made an amazing discovery this way.
Jodie Foster did make an amazing discovery that way in the movie Contact, that is true. "Why build one when you can have two at twice the price?" would be my engineering takeaway from that movie though.
This has been my experience as well. LLMs know the patterns but often need to be nudged into choosing the proper one.
> I'm really struggling to see how to make architectural decisions with an agent. It's great when you're at a total loss for ideas
I feel the opposite, like if I go to an agent without first knowing what I want to build, I'll never figure out what I'm doing or why and it'll run away from me.
I pretty much always go back and forth and have the agent write out a plan to a file and review it myself in my text editor. I still sometimes end up with surprises I disagree with, but I don't really find it to be true that the LLM ends up trying to "drive all of the thinking".
When I'm thinking through an architecture, I not only instruct it to refrain from writing any code, I don't even necessarily tell the agent what I'm trying to build.
> I'm really struggling to see how to make architectural decisions with an agent.
I walk to work and home with ChatGPT Voice and AirPods. I ask it to be Socratic and I just start rambling the top of thing on my mind. After 20 mins of back-and-forth it's usually teased an answer out of me or I've teased an answer out of it.
Sometimes it's easier for me to scaffold the architecture (in real, working code) and then let the agent fill in the implementation. And I make the agent document the architecture and have it refer to the documentation when coding. When I review agent code, I focus only on architecture (is it following existing architecture? is it introducing new structures, dependencies, etc.?)
Other times, I let the agent create a black box with a well-defined interface contract. I don't care about the architecture inside the black box.
This is one thing I actually do with a chatbot, instead of an agent. Voice mode even.
I start talking to it while doing menial tasks like cleaning or doing the laundry, and I discuss the architectual decisions and options until I come to some resemblance of a plan.
Good side of this approach is that I can't just "skim over" or "copy paste" things - either I understood them and can repeat them myself, or I can't. It takes more time than /grill-me and similar approaches, but it's the only approach that doesn't make me want to claw my brain out.
+1. I have found that most coding harnesses are too focused on the doing that using a Claude/chatgpt chat gives me a lot better quality.
How much scope do you give it? I find it's easier to stay in control when you give it scope down the chunks of work you give it.
Why would you care about architecture? It was an issue when humans were writing code so architecture mattered in the sense that you needed a sweet spot between current requirements and future extensions.
The agent can rewrite half your codebase in one day, so architecture stops mattering for the most part.
Almost all scalability and performance optimization is architectural in nature. AI writing the code doesn't eliminate this concern.
Some apps don't care about scalability and performance but many do. Ignoring architecture all but guarantees inefficient, wasteful software.
Why try to make things that are good? Why care about anything? Why not just turn our minds over to the machines, and let them rock us to sleep like babies?
Possibly because the goal is the end product that serves a purpose and has value, not the process. If you can make your product, make the customer happy, and make your money to enjoy your life and secure your families future… why care who or what or how (as long as it’s ethical obviously).
Every choice has a cost. The question comes as to when you pay it. Your idea of an end products behavior, and the end products behavior when it interacts with reality may differ significantly.
For example is unknowingly writing a security flaw ethical, when you could have used a set of processes to reduce them before release that would have make the entire thing take longer and cost more. Seems like programmers need a lot more ethics classes as ethics are part of any large scale process.
Abstractions. They make it easier for a human to understand. We need abstractions to fit systems into our working memory. Agents dont.
Agents don’t have infinite working memory…
LLMs benefit from abstractions for the same reasons that humans do. More information in the same amount of text. Fewer working parts to juggle so fewer ways to make mistakes.
How are you going to read the code if it's not structured in a way you understand?
An agent can rewrite a small codebase in half a day, I have millions of lines of code - it can't rewrite that in half a day.
Mhh I've tried one-shotting double buffered IO a few times and it just can't do it. Maybe it's a prompting issue, maybe LLM's have a hard time with thinking about parallel processes.
I'll create a simple "framework" of what I know works. After that's there the LLM is fantastic.
Why would you care about architecture? Ability to implement the current feature, ability to implement future features, maintainability, and (at least sometimes) performance.
But why would you care when an AI can just rewrite it? Yes, but can it rewrite it to a good architecture? Or just to a different one?
Does a good architecture make code easier for an AI to maintain? I don't know, but I think it's at least not proven that it doesn't.
It’s important for separation of concerns, which is important for maintenance and future iteration on features and bug fixes. If you don’t have separation of concerns, every change to anything is essentially a from scratch rewrite of the whole thing. That’s also incredibly inefficient in token usage.
I have had really good experiences with designing architecture with agents. It is much much better than humans and frankly, if my colleagues had used agents to design their new services, we'd have been in much better place.
Treat the final "here's what you should do" summary as just another intrusive thought.
I have found autonomous agents to be pathetic at architectural decisions.
Architecture has remained so far to be one of those domains where skillset dwarfs everything by comparison.
I think I need to write a full blog post on this.
While I think there are better introductions to "first principles thinking" than this post, the idea of "...When I step back and ask what we’re actually trying to do, why it matters, and how the pieces connect, I usually find more ways forward than I expected."
That's an important skill to have.
However, I think sometimes we overvalue thinking from first principles when it isn't warranted. I've seen times in my career where first principles thinking led to a solution that ignored key non-technical constraints. (For example, it would require a full re-architecture of the system and require deferring all feature work for a year. Another example: the proposed solution breaks Conways law in a way that would require a reorg that would break other organizational constraints.)
Sometimes, we need to recognize our constraints. Spend the time to question them when appropriate, but realize that there are other tools that are more appropriate in some cases -- such as anthropological thinking.
> However, I think sometimes we overvalue thinking from first principles
The problem isn't the thinking though, but the lack of grounding.
You don't have a problem with people coming up with a technically better solution. Your problem is with the people not realizing that they exist in reality and not in a vacuum.
Please don't question the act of thinking itself. It is the wrong target.
From the blog he linked to: "I’m going to try designing something way more ambitious."
This is how you end up with unnecessary complexity [1]. The best engineers don't aim for "designing something ambitious", instead they come up with the simplest possible design. They take something that seems complex and make it simple.
Unfortunately that's not how engineers are evaluated [2].
[1] https://goomics.net/316
[2] https://terriblesoftware.org/2026/03/03/nobody-gets-promoted...
The best engineers don't aim for "designing something ambitious", instead they come up with the simplest possible design
These are orthogonal.
A lot of the dissonance on HN appears to come from two groups of people talking past each other:
a) developers working at some corporation they hate vs.
b) developers working for themselves or somewhere they don't hate
"I am going to solve a complex problem" is a better goal. If you start with the goal of designing something ambitious then the design will likely end up more complex than necessary.
Orthogonal does not simply mean different.. simple and ambitious designs often run askew of each other but they can also share the same line.
Lots of words, not a lot of meaning. What is this post about?
> When you truly understand what you’re trying to accomplish, it’s easier to take a small step...
I think they're describing an approach to decision-making in the context of agents.
Engineers encountering LLMs for the first time think the problems they encounter are entirely novel, but really we are rehashing old lessons which Fred Brooks wrote about half a century ago, but in new jargon.
The essential difficulty of specifying what you actually want remains the same and nothing I've seen from LLMs will change that.
I think it's saying you need to go back and think harder about the problem instead of putting all your effort points into a solution.
Whatever it is you are doing, consider the very basic reason for doing it. And then, build your solutions from there from what is available. Examine the first principles of whatever it is you're doing.
You are working, and you are building things, to create value.
What are the tools you use to move about your environment and create your product, your value? Your knowledge, your training, your time.
If you examine the first principles of whatever it is you're doing, you should realize: you must keep your toolbox open and ready to swap new tools in and out in order to keep up with the time and manage yourself effectively.
AI is a tool, learn to use it as a tool and stop 'fighting the times' so much. All of your criticisms are valid, and you are correct: but everyone still wants to save time, and so you must keep up.
Original author here. ^ bingo.
Very confusing indeed. Is the core idea to read the picture as a flow from left to right? Or some people go down and left, but you need to first go right and iterate. Then go left and put it in a box. and then... dunno, lost track of thought, did AI or someone who is very new to Consulting write this?
"First principles" is just the latest expression ruined by SFBA posers like "orthogonal" and "non-trivial" before it.
I've been using codex to design and build a product that is a fairly conventional looking app - think of a gmail like experience - with some delicate synchronization across devices.
I find that I need to invest a whole lot in high level design myself to get Codex to create a suitable architecture and make the right tradeoffs. It's more like I am designing and Codex is reviewing and occasionally we brainstorm. When I tried having it design based on requirements, it went wild with an unsustainable design / architecture.
And I use things like plan mode etc. My experience is unlike what I read in most vibe coding exploits.
I wonder if I am doing something wrong. Is there a good canonical example of a project built with Codex or even Claude Code that shows how the human and AI interact that I could use as a reference
> occasionally we brainstorm.
Seriously, how do you brainstorm with an entity that would 180 if pushed a bit..How can you take anything it say at face value?
I've been on a similar path, and I used to put time in high level design, as it was basically required in some cases. But not a lot of time, because smaller agents research, perform small tests, whatever to inform the high level design. Working incrementally seems to help, maybe prompting a bit more often, but the same can be accomplished with well defined checkpoints.
Then generalize + standardize that process, get an agent to replace you as high level designer so you can manage a team of high level designers, etc etc
more time in plan mode, less time in build mode. This is true regardless of whether an agent does it or you do it.
<wrong thread>
Sorry, I think I'm being dumb, but where is the "first principals thinking" in your example?
Common sense is not so common
Sometimes I don't understand what "first-principles thinking" is, or what exactly you have to tolerate in code for it to count as first-principles.
This is one of those things where one can throw around the term "first principles thinking" with relative ease.
To actually do it is different and usually comes from having to wrestle with a problem.
Sadly people from the academia and the public at large has a hard time understanding what this even means.
They equate it with exam based memorization or delegation to authority. Funnily they even think first principles reasoning is an improved version of doing the same.
But this is a blessing in disguise as it gives those who wrestle with real problems a unique skillset that can be advantageous.
> Sadly people from the academia [...] equate [first principles thinking] with exam based memorization or delegation to authority.
In what departments and at what universities? The term "first principles" comes from academia. I think you'd be hard pressed to find a faculty member in any philosophy department doesn't understand what reasoning from first principles is. I'd be surprised if any working mathematician thinks of "memorization" or delegating to authority rather than axiomatization. What experiences led you to say this?
Its so ubiquitous, you can pick random folks from most academia and see it first hand.
If this comes as a shocker to you, then I should be the one to enquire as to how you managed to stay blind in the face of the obvious.
Just strike up a discussion on some complex topic, and you can see many people resort to "because the author here in this book said" or "we are taught so and so".
A first principles reasoning can show you the steps that lead to a specific conclusion without invoking any author, teacher or course.
Cheers. Hope it helps.
And it's a skill that you'll use in other contexts. Over too learn and practice it in IT/physics, and you find out that you can use it to psychology, humans around you are dealt with another depth and different outcomes become possible
Agreed. The skills at sufficient depth are increasingly transferable accross domains.