How AI Automates Fast Decisions in Software Engineering
AI is shifting the software engineering landscape by taking over "fast decisions"—the automatic, high-context but low-complexity tasks like running tests and catching syntax errors. This frees up developers to focus entirely on "slow decisions" like system architecture, API boundaries, and product design.
I’ve been thinking a lot about the book Thinking, Fast and Slow lately. The core point of the book is that your brain operates in two distinct modes. When you're walking down the street, your brain is in a fast, automatic mode. You're navigating around other people on autopilot, making decisions without even realizing you're making them. But then you have slow decisions—like choosing which barbecue to buy for your garden. That takes deliberate, conscious thought.
When I think about how we interact with AI, this is exactly where I see things heading. AI is starting to pick up the fast, automatic decisions we make in our day-to-day engineering jobs, and that is going to fundamentally change how we spend our time.
How does Kahneman’s theory apply to writing code?
In software engineering, fast decisions are the low-friction, repetitive tasks we execute on autopilot, like running a test suite or fixing a syntax error. Slow decisions are the deliberate, strategic choices, like architecting a system or deciding on a test coverage strategy. AI is stepping in to run the fast decisions so we can focus entirely on the slow ones.
For example, when I am writing code, deciding whether to run the unit tests isn't really a decision I need to make. Of course I should run them. That is a fast decision. But deciding how those tests should be written, what scenarios we need to cover, and how the overall system should behave—those are slow decisions.
If we can offload the automatic "yes, run the tests" layer of our workflow, we reclaim the mental space needed for the hard, analytical design work that actually moves a project forward.
What are the "fast decisions" we can offload to AI?
Fast decisions are deterministic tasks that require local codebase context but very little creative reasoning. When I use a coding agent, I want it to handle things like running unit tests after a change, fixing formatting issues, or cleaning up import statements. These are things we can easily automate once an agent has enough context about our workspace.
I like to split these developer decisions into two distinct categories based on how much deep thought they require:
| Decision Type | Developer Mode | Task Examples | AI Agent Feasibility |
|---|---|---|---|
| Fast Decisions | Autopilot (System 1) | Running unit tests, fixing syntax issues, formatting code, basic refactoring. | High (Can be fully automated) |
| Slow Decisions | Deliberate (System 2) | Designing system architecture, defining test coverage strategy, API design. | Low (Requires human reasoning) |
How does delegating these decisions change our day-to-day jobs?
Delegating fast decisions to AI keeps us out of the constant loop of minor distractions, allowing us to stay in flow state longer. It means we stop wasting cognitive energy on routine tasks and spend it instead on deep architectural work.
Let's say you are building a payment processing service. In a traditional workflow, your day is fragmented by micro-decisions. You write some logic, manually trigger a test, fix a linter warning, check a configuration file, and then try to get back to your main train of thought. Every minor system step demands a small action from you.
If you hand those fast decisions to a coding agent, the agent runs the tests, formats the files, and flags obvious errors in the background. You don't have to decide to do those things; they just happen. This frees you up to think about the actual business logic, concurrency issues, and edge cases. It changes your job entirely.
FAQ
Can AI handle slow decisions in our codebases?
No, because slow decisions require deep context, trade-off analysis, and human-centric design. AI can offer suggestions, but deciding how a system should scale or what security model to use still requires human judgement and deep technical expertise.
Will this automation make junior developers obsolete?
I don't think so, but it will shift what we expect of them. Instead of spending their first year learning to write boilerplate and debug configuration files, they will need to learn system design and how to orchestrate AI tools much earlier in their careers.
How do I prepare my codebase for AI automation?
The best way is to make your fast decisions as deterministic as possible. If you have a clean project structure, fast test runs, and clear linting rules, it becomes much easier for an AI agent to step in and make those routine decisions for you.
