Let's Chat

Tools & Workflow • LLM

Becoming a Programmer in the AI Age: The LLM Assisted Programmer

A roadmap for thriving as an LLM-assisted programmer: master fundamentals, understand the caveats of LLMs, and build incrementally while staying in control.

13 min read
Focus LLM-Assisted Development
Experience 20+ Years Web Development
Tools Cursor, Claude Code, OpenCode, Droid
Approach Incremental & Fundamentals-First

The Landscape

I began my development journey in 2000. That "aha" moment when you create something from nothing was the spark for a 20+ year career in web development. Today, vibe coding has created a new breed of developers that create at the speed of thought. Code is cheap, and you are only a prompt away from creating an application. This begs the question: is coding really that cheap?

Over the past two years, I have been developing extensively with LLMs. After experimenting with one-shot prompting, multi-agent development with worktrees, and BMAD, I've concluded that an LLM is like any other tool in your arsenal: it possesses great power depending on how you wield it.

Today there are essentially three types of developers using LLMs in the market. The Vibe Coders and the Agentic Engineers get most of the attention. The LLM-Assisted Programmer is talked about the least—but I believe it's the one that best aligns with a programmer's principles and their job role.

The Vibe Coders

Casual developers with little to no prior experience who use no-code or generative UI tools like Lovable or v0 to build applications.

The Agentic Engineers

More technically savvy users who may be programmers. They aim to build using CLI tools like Claude Code, OpenCode, or Droid.

The term "vibe coding" is often used interchangeably between these two groups — and for good reason. Despite differences in tooling, they share two defining traits: they rarely review or inspect the generated code, and they rely almost entirely on prompting under all circumstances.

Recommended path

The LLM-Assisted Programmers

Developers with deep programming knowledge and a fundamental grasp of their domain. Most are long-time IDE users who were familiar with "autocomplete" long before the AI age. They still want to see the code and remain involved in the entire process, carving out expectations together with the LLM using IDEs like Cursor or VS Code. This path offers the best staying power and flexibility as the industry evolves.

The Roadmap

To thrive as a programmer in the age of AI, I believe you need to follow this roadmap:

1. Master programming fundamentals

Focus on concepts, not just the syntax of a specific language.

2. Complete a specialized course

Take a structured course (e.g., Udemy) in your chosen field, such as web development.

3. Understand the caveats of LLMs

Know what Large Language Models can and cannot do before you rely on them.

4. Build without autocomplete

Build a simple application without any autocomplete tools to prove your fundamentals.

5. Build with standard autocomplete

Build a second application using standard autocomplete to feel the difference.

6. Build in collaboration with an LLM

Build a third application as a true collaboration with an LLM, applying everything you've learned.

Programming Fundamentals

To be successful in programming today, you must master the fundamentals. The basics of every programming language consist of a few simple concepts that you can learn within a week or two.

Variables

The building blocks for storing and manipulating data in any program.

Logic Controls

If statements, conditionals, and branching — the decision-making core.

Loops

Repeating operations over data sets — for, while, and iteration patterns.

Functions

Encapsulating reusable logic into named, callable units.

Variable Scope

Understanding where variables live and how they're accessible.

OOP

Classes and methods — organizing code into objects that model real-world concepts.

Least distraction learning

These fundamentals exist in all programming languages. Focus on the concepts themselves without the distractions of complicated environments or complex build scripts. Start with JavaScript, PHP, or Python. Avoid jumping straight into React or TypeScript; you will likely get bogged down in unnecessary complications before you truly understand the basics.

A good measure for your knowledge

In programming, a single problem can have many different solutions. Without a solid understanding of design patterns and logic, you might accept LLM-generated code that "works" but isn't actually the best solution. Even experienced programmers write "crappy" code. Because LLMs are trained on this vast sea of existing data, they are just as likely to apply those same patterns to your application.

Self-check

Ask an LLM to generate a feature, then go through the code from start to finish. If you can explain exactly what is happening — without asking the AI for help — and understand at least 80% of the underlying logic, you have a solid foundation.

The Caveats of LLMs

I prefer not to use the term "AI" because these models aren't "intelligent" in the human sense. Large Language Models (LLMs) is a much more accurate description. They are statistical, probabilistic models trained on human-created data, predicting the next most likely piece of text. Understanding these weaknesses will help you better manage LLMs in your programming journey.

Caveat 1: They act like they have all the answers

An LLM is like a world-knowledge encyclopedia — or a super-smart, arrogant human. They will also "make things up" when they lack the right information. If their training data is limited in a specific area, the model will provide an answer that sounds confident and correct but is actually a "hallucination."

Caveat 2: Not all LLMs are created equal

If you visit platforms like OpenRouter, you'll see over 600 different models. Each performs differently, with unique capabilities and knowledge bases. It is crucial to know which model is best suited for your specific task.

Caveat 3: Training data is a mixed bag

LLMs are trained on the internet, which contains both truth and misinformation. Since every answer is delivered with the same tone of authority, the responsibility lies with the user to validate the information, especially for critical tasks.

Caveat 4: No two answers are exactly the same

Because LLMs are probabilistic, they don't use rigid templates. Unless a topic has only one possible logical answer, the way the model delivers information will likely vary every time you ask.

There's another layer to this: when you program, you're going through a "harness." For now, think of the IDE you're coding in as that harness. When you prompt through an IDE, it doesn't pipe your prompt directly into the model — it usually runs a combination of steps first. As a result, the output you get may not always come from the exact same prompt that actually reaches the model for the final response. This may sound confusing; I'll go into harnesses in a separate post.

Caveat 5: Contextual knowledge has limitations

The Context Window is the amount of data you can feed into the prompt at once. Think of it as your "source of truth." If you have a large codebase, an LLM cannot ingest all of it at once — you must intelligently feed the window with relevant information. Sometimes the context can be contradictory; how an LLM handles this depends on the model, your prompt, and the IDE you are using.

Remember

Before you start coding with an LLM, you must understand these limitations and know how to resolve problems manually. Tools and IDEs are "shiny new toys" that may come and go. Understanding the mechanics helps you write better prompts and ensures you remain the expert in the chair.

Professional Workflow

Programming remains fundamentally the same. When working on a project, you still need to follow a rigorous software development lifecycle (SDLC): defining requirements, creating user stories, developing wireframes, programming logic, and testing. In a professional setting, you must adhere to strict requirements and specific sign-off processes. LLMs are currently not capable of that level of precision on their own.

Reality check

You have likely heard that programmers are no longer necessary — that "autonomous agents" can build a product from a single prompt. While this might work for a To-Do app, it fails in the real world. Complex systems require standard development principles. Always remain in total control of the output.

Planning and brainstorming

LLMs significantly accelerate the early phases by acting as sophisticated brainstorming partners. They can quickly generate diverse solutions, identify edge cases, and draft preliminary functional requirements. I use these insights to put together a Product Requirements Document (PRD), which serves as my roadmap.

Wireframes and design

With a PRD in hand, I begin developing the UI step-by-step. Visualizing the application — from login to the specific feature pages — is the most comprehensive way to validate the PRD. It provides essential context for stakeholders and helps small startups build an MVP without the immediate overhead of a full design team.

Backend programming

Backend development is essentially about receiving, processing, and saving data. Most features are CRUD operations, which are simple for LLMs to handle. However, when a feature involves unique business logic, you must have a clear mental map of the execution. I often write comments within a function to describe the logical steps — Input → Processing → Output — before even touching the code.

Principles for Building with LLMs

To maintain high standards, I follow these core principles:

Never "one-shot" an application

Expecting an LLM to build a complex app from one prompt results in broken features and missing requirements. The larger the application, the harder it is to spot these silent failures.

Build from a UI / wireframe

A visual representation ensures a unified understanding among the team before programming begins.

Know your steps

Work off a completed UI, building from the start of the user journey (e.g., registration) and moving through the backend requirements incrementally.

One piece at a time

Code your application in small chunks. I use IDEs like Cursor in "Plan Mode" to flush out inconsistencies. Build and test the registration endpoint before ever starting on the login logic.

Explain your logic for complex features

If an LLM struggles with a unique domain, write down your logical thoughts first. LLMs are excellent at language syntax but often fail at novel logic. This is where your fundamental coding knowledge is critical — guide the AI or write the code yourself.

Key Takeaway

Prioritize programming fundamentals over specific frameworks to effectively manage LLMs as development assistants. Authentic expertise allows you to act as a necessary filter — ensuring you can understand and refactor AI-generated code into elegant, optimized solutions. The LLM's greatest value lies in accelerating ideation and boilerplate phases. They should never be used to "one-shot" an application; instead, they should assist in an incremental process where the developer maintains 100% control.

Summary

As a programmer, I've always felt that when you develop an application from scratch, your progression should make you more knowledgeable about the application. As you reach completion, you should feel — and get the sense — that the overall application is solid and you've covered your bases.

The thought of handing your complete work to a client should not come with uncertainty. Honestly, if I cannot get myself to feel this way when a project is complete, how could I call myself a professional?

Would you go get surgery from a surgeon who tells you: I'm not 100% sure about what I did, but it should be okay?

Let's talk

If this resonated, I'd love to hear from you. Whether you're mapping your learning path or building with LLMs and want a second pair of eyes, get in touch.

Get in touch

Topics

LLM Career Programming
← Back to Blog