How LLM‑Powered IDEs Can Cut Your Coding Time in Half

Reading note: Using large language models (LLMs) will forever change how software engineers write code.

Last weekend I used Cursor, an LLM‑based IDE, to create a hobby project. I wrote no code myself (and received no sponsorship). The whole project took me a weekend; without an LLM it would have taken at least a week.

Although the LLM is not perfect (its shortcomings are discussed later), it handles the repetitive, unsatisfying parts of programming very well.

New Coding Behaviour

When a single command can generate a complete feature, an interesting thing happens: discarding code and retrying with refined prompts becomes more efficient.

Debugging bad code is much slower than prompt engineering.

Typical development flow: discard changes until it works

This approach has pros and cons. I work faster but understand the code far less. The code makes sense in isolation but becomes odd when the scope narrows.

For example, I once had two competing data models for the same concept. Writing the code myself would have avoided that obvious design error.

LLMs also make inserting print‑statement debugging easier than using a debugger. Previously I preferred debuggers for speed, but now I can inject high‑quality print statements anywhere with a simple prompt, then clean them up just as easily.

Goodbye Google

Most of the time LLM responses are better than Google results, providing more targeted answers so I no longer need to read tutorials or search Stack Overflow. Only a few times do I still turn to Google.

Two real examples:

I wanted a Chrome extension that could overlay the current page without changing its DOM. The LLM gave a clear answer to inject a component, while Google offered a better solution that met my requirement.

Creating an OpenAI API key without a registered credit card returns a 429 error. The LLM suggested caching and rate‑limit code, which made sense but didn’t solve the problem; Google revealed the issue was the missing credit‑card record.

Understanding Your LLM

You need to know how to query an LLM to get the most out of it. After a day or two of trial you’ll learn what works and what doesn’t.

I mainly use Claude‑3.5‑sonnet because it is fast and reliable. When Claude struggles, I switch to the strongest model I know (e.g., OpenAI’s O1), which is slower and costs about $0.40 per request.

If a request fails, I break the task into well‑defined subtasks.

The chart shows I used Claude‑3.5 373 times and O1‑preview 46 times over the weekend.

Ideally LLM tools would automatically pick the appropriate model based on task difficulty; until then, manual knowledge of each model’s strengths helps balance quality and cost.

What Matters Most Now

Even though LLM‑driven development is faster, many limitations remain. Skills that help overcome these limits include:

Advanced planning and design – LLMs handle detailed, well‑scoped algorithm changes easily, but they struggle with high‑level architecture, so roadmap and technical design become crucial.

Debugging – I can sometimes dump errors into an LLM and get help, but obvious mistakes (e.g., deleted critical code or renamed functions) still trip the model.

At the time I was building a simple full‑stack app; the LLM’s training data contains many online examples and unambiguous boilerplate code.

For many proprietary, cutting‑edge codebases, this approach is far less effective.

LLM‑generated code is a powerful tool for simple, well‑defined tasks, but it does not mean AI is stealing developers’ jobs.

Try it yourself and you’ll see it is still far from replacing human developers.

I am optimistic that these coding tools will improve our lives, making English‑based programming feel great, allowing us to express ideas with less time and effort.

It reminds me of the satisfaction felt in career development: high‑leverage work is far more interesting than fixing compiler errors or missing semicolons.

It frees us to do fun, creative work.

Author: Listening‑to‑Music‑Fish

Related reading:

Beginner’s Guide to OpenAI Text Embedding Models

What Is a Large Language Model? How Does It Work?

Step‑by‑Step Guide to Running Llama 3 on macOS (M1/M2/M3)