The sixteenth draft of my Chinese dictionary lies abandoned in a folder deep within my repo. Two weeks of work, genuinely good code, completely functional. Pre-AI me would have shipped it just to justify the time spent. Post-AI me deleted it and started building something better. That folder of abandoned ideas tells the real story of how AI changes everything.

This is the new math of being a builder: idea exploration is free, but shipping still takes weeks. With AI, we're not simply moving faster, we're taking better bets.

I'll illustrate this through my experience building koucai.chat, a Chinese language learning app, from zero to production in a few months. I am a professional software engineer, so I'm not using AI to replace my coding knowledge, but instead to allow me to achieve more.

Here's what changed.

Moonshots

      SCARCITY                    ABUNDANCE

           ●                      ● ● ● ● ●
                                  ● ● ● ● ●
      precious                    ● ● ● ● ●
      resource                    ● ● ● ● ●
                                  ● ● ● ● ●
           ↓                           ↓

      "protect                    "explore
       the idea"                   everything"

By making action cheap, AI allows us to take bigger risks and chase moonshot ideas. Cheap action gives us VC logic - make ten bets, expecting eight to fail.

But, that raises the question, shouldn't someone with a good product sense already know where to apply their efforts, have an idea of what they should be building?

Certainly, we should know what to do, but in practice, we don't know how hard it will be, or what the value will be, until we actually do it (the reason that correctly estimating timelines is a rare and esteemed skill).

Some examples from Koucai are:

Building a Chinese-English dictionary

• Online free dictionaries didn't have the level of detail I wanted
• I wanted to experiment using AI to fill in the existing dictionary with extra information such as particle, example sentences, collocations, etc.
  • (I know - using AI for language learning is a bad idea. However, I theorized with a high enogh (95%+) accuracy, the benefits would outweight the drawbacks)
• I built out a prototype for this, but I realized that it didn't have the level of accuracy and quality that I required

After two weeks of building this (in parallel with other features), I had three options:

1. Ship the 80% solution (fast, but dictionary quality would degrade the user experience)
2. Spend another month reaching 95% (production-quality, but at cost of delaying other core features)
3. Abandon it and use existing dictionaries (pragmatic, but compromised on my needs)

I picked #3. If I had written everything by hand, I likely would've picked #2, as the sunk cost was real, and 'almost done' feels too close to quit.

But, when prototyping is cheap, sunk costs stop mattering. The real question became: Is this the best use of the next month? It wasn't.

Implementing a scenario feature

• I wanted to implement a feature allowing users to place the AI character in different "scenarios"
• I wasn't sure how this would look, so I ideated on the feature a bit, and then set my buddy Claude out to build it
• The result: a feature that significantly improved the 'fun' factor of the app, built in days instead of never leaving my brain

Without cheap action, I would have been much less likely to take the risk of investing time into this unknown idea

Failure is now affordable. Since action is cheap, so is failure. However, the learnings gained from failure are still real.

Compression of Action

TRADITIONAL:

    Think ──────[weeks]──────> Do ──────[weeks]──────> Learn
      ↑                                                   │
      └────────────────[iterate slowly]───────────────────┘


WITH AI:

    Think ─[hours]─> Do ──[days]─> Learn ┤
      ↑                                  │
      ├──[hours]──> Do ──[days]──> Learn ┤  (parallel paths)
      │                                  │
      └──────[rapid iteration]────────-──┘

The most dramatic effect AI has had on the Thinking <-> Doing cycle is the compression and parallelization of action.

The time it takes to make visible changes, especially for greenfield projects, is shortened due to the extensive knowledge and crazy speed that AI can write new code. Additionally, agents can be parallelized, scaling out work, where the only limit is the cognitive overload of managing the agents.

With AI, action has become cheap. Necessarily, this places more weight on the longer-tail cycle of Thinking, changing the calculus of being a software engineer. Each idea has the potential to become something real and tangible - all that's required is the desire to bring it into reality.

Doing good things is still hard

AI compresses the Thinking <-> Doing cycle, but it doesn't actually make doing good things easy. Even though AI is fast at writing code, and can do so in parallel, building software with professional standards using AI isn't actually always faster. Thankfully for those of us in the industry, software engineering is still a delicate and difficult craft, and, despite claims to the contrary, continues to require a high level of coordination and thought by a human.

Getting to demo quality takes days. Getting to production quality still takes months. The difference is now, we have a better idea of if those weeks are worth it.

This is due to the lack of a world model in LLMs. Their view of the world is so simplistic that it isn't able to have the 10000ft view that is required to build software systems. AI excels at generating code but stumbles on the invisible: system constraints, cross-component dependencies, and the accumulated decisions that shape mature codebases

Where AI does help is the parallelization of your skill. Each AI agent can be working on independent task, and you, as the orchestrator, can coordinate the agents and steer them in a correct direction

An example is implementing a guest user flow. I dislike when apps require you to have an account before trying it out, so I decided to allow un-authed users to trial Koucai. Doing so sounds easy, but in reality it doubles the amount of surface area for bugs related to auth, both in the frontend and backend. Implementing the feature took about a week of refinement, testing, and lots of back-and-forth with the AI before it was in an acceptable state.

Thinking is cheap now?

YOUR IDEA                          YOUR IDEA + AI
    ┌─────────┐                       ┌─────────────────┐
    │   ∙     │                       │  ∙   ∙   ∙      │
    │         │  ──────[ AI ]──────>  │    ∙   ∙   ∙    │
    │    ?    │                       │  ∙   ✦   ∙      │
    └─────────┘                       │    ∙   ∙   ∙    │
     (fuzzy)                          └─────────────────┘
                                      (explored & refined)

When we can offload our thinking to AI, what remains uniquely human?

AI takes our ideas, and shifts them in new and unexpected ways via the stochastic nature of the LLM. Taste is knowing which path to take when AI shows you ten.

There are two paths that can be taken when working with AI:

1. Using AI to replace your ideas
2. Using AI to enhance your ideas

Someone who is doing #2 can use AI as an idea validator, expander, enhancer, and thought partner.

I knew design was critical for Koucai. To me, it's not simply a product. I'm building somewhere for people to go online. Form and function are intertwined. I wanted something beautiful. Specifically, I wanted Bauhaus principles (geometric, functional, bold) but couldn't figure out how to reconcile that with minimalism.

I gave AI my constraints and references, design aesthetics I admired, the tension between bold and minimal. It generated multiple directions. My first attempt used aggressive shadows and heavy contrast, which was technically Bauhaus, but too loud for an interface people use daily. After iterating through variations, I landed on neo-Bauhaus × 間 (ma): geometric structure with intentional negative space, bold where it matters and restrained everywhere else.

The framework stuck. Now when I face design decisions, I have a lens: Does this honor geometric clarity? Does it use negative space intentionally? Is the boldness purposeful? AI helped me explore the space between my constraints, but I had to recognize the right answer when I saw it, and know when the first answer (aggressive shadows) was wrong.

This is the paradox: AI makes idea generation cheaper, but judgment becomes more valuable. You need taste to navigate the expanded possibility space. Which of these ten directions actually serves your users? Which honors your vision vs just looking cool? Which is bold enough to differentiate but restrained enough to live with?

Taste becomes king in a world run by AI.

What this means

Engineers who succeed in an AI world aren't necessarily the fastest coders, greatest prompters, or hardest workers - they're the ones who can orchestrate multiple AI agents while retaining coherence, curate ideas ruthlessly, and know when 'good enough' truly is good enough.

We're entering an era where the cost of being wrong approaches zero, but the value of being right remains unchanged. The engineers who'll thrive understand this new math: build ten things, ship three, learn from all ten.

The real divide isn't between those who use AI and those who don't, but between those who maintain their judgment/thinking and those who outsource it.

Which will you be?

Advice

Open your backlog. Pick an item that you didn't pick up because it seemed too complex or wasn't important enough, and give yourself 4 hours to prototype it with AI.

You'll either prove it's impossible, or discover it's not.

Either way, you've converted a vague idea of the problem into tangible knowledge. That's the real value.

— Ben

Articles I enjoyed while thinking about this post: https://dcurt.is/thinking https://yosefk.com/blog/llms-arent-world-models.html