Intro to Using AI in Software Development — from how models work to shipping with them

AI has gone from novelty to a daily tool for writing software, and this path is a guided, hype-free tour of how to use it well. Start under the hood — how large language models are trained, how they actually decide what to write next, and how the context window that feeds them really works — then map the landscape: which providers and models are used for coding, their strengths and trade-offs, the interfaces you reach them through, and how usage limits and cost work. From there you'll compare the ways people code with AI — the provider's app, an IDE integration, an agentic CLI, or a blend — and the whole spectrum from line-by-line completion to full "vibe coding". You'll learn to steer a model with prompts, skills, and AI config files, and to weigh one model against a combination of several. The path ends by helping you choose your own model, provider, and method and put AI to work in a real project. No coding background required, though the Intro to Software Development path pairs well; examples lean on real software, including the kind of signal-crunching code behind GopherTrunk.

Start lesson 1 →Jump to glossary

“Using AI to write software” sounds like one skill, but it’s really several — a working model of how these systems actually behave, a map of the providers and their costs, a feel for the different ways to plug AI into your work, and the judgement to steer it and check what it gives back. This path builds that stack one short lesson at a time, starting from how a model decides what to type next and ending with you putting AI to work in a real project.

Who this is for. Anyone who wants to use AI for development on purpose instead of by superstition — whether you’ve never written code or you already ship it daily and want to go from “it sometimes helps” to a deliberate workflow. No prior AI knowledge is assumed. If you’re brand new to programming itself, the Intro to Software Development path pairs naturally with this one; every lesson here is self-contained and cross-linked, so you can read straight through or jump to what you need.

How the path works. Six modules move from understanding to doing. We open under the hood — how models are trained, how they decide what to write, and how the context window that feeds them really works — then map the landscape of providers, models, interfaces, limits, and cost. From there we compare the ways people actually code with AI (the provider’s app, an IDE, an agent in the terminal) and the whole spectrum from line-by-line completion to full “vibe coding”. Module 5 is about control — prompting, skills and config files, and choosing one model or many — and Module 6 turns all of it into a concrete plan for your own projects. Facts that age quickly, like exact prices and model names, are taught as how the mechanism works with current examples, so the ideas stay useful as the tools change. Examples lean gently on real software — including the kind of signal-crunching code behind GopherTrunk — to keep things concrete. Mark lessons complete as you go; your progress is saved in your browser. Start with lesson 1: What is AI, for a developer?

Module 1 — How AI Models Actually Work

Under the hood before the hype: what an AI model is, how it's trained, how it decides what to write, how context works, and which kinds of models write code.

  1. What is AI, for a developer? LLMs, "narrow" vs "general", and why today's coding AI is next-token prediction rather than understanding — the one idea everything else builds on. beginner 9 min
  2. How AI models are trained Pretraining on oceans of text, fine-tuning, and RLHF — and why training explains knowledge cutoffs, bias, and the confident wrong answer. beginner 10 min
  3. How a model decides: tokens & prediction Tokenization, next-token prediction, temperature and sampling, and why the same prompt can give different code — and sometimes invents an API that doesn't exist. beginner 10 min
  4. The context window, in detail What "context" really is, why it's measured in tokens, the window's hard limits, attention and "lost in the middle", and why context is both your biggest lever and a cost driver. intermediate 11 min
  5. The types of AI models LLMs, reasoning models, embeddings, multimodal, image and speech models — which ones write and plan code, and which power the embedded-AI features a later path will build on. intermediate 10 min

Module 2 — Providers, Models & What They Cost

The market you're choosing from: the major providers and models for coding, their strengths and weaknesses, the interfaces you reach them through, and how limits and cost work.

  1. The provider & model landscape The major AI providers, proprietary vs open-weight models, and a durable way to think about a field that ships a new leading model every few months. beginner 9 min
  2. Coding models compared The strengths and weaknesses that actually distinguish coding models — capability, context size, speed, autonomy, and cost — framed to outlive this month's leaderboard. intermediate 11 min
  3. Interfaces: app, API, CLI & IDE The handful of ways a model reaches you — web chat, raw API, command-line tools, and editor plugins — and what each interface is and isn't for. beginner 9 min
  4. Usage limits & tiers How rate limits and caps actually work — messages, tokens per minute, usage tiers — the difference between subscription and API metering, and how to design around them. intermediate 9 min
  5. Understanding the cost Token pricing for input and output, subscriptions vs pay-as-you-go, prompt caching, the real cost drivers, and how to estimate what a workflow will spend. intermediate 10 min

Module 3 — Ways to Use AI in Your Workflow

Where the AI actually lives while you work: the provider's app, your IDE, an agent in the terminal, or a deliberate blend — with the honest pluses and drawbacks of each.

  1. Using the provider's app The chat window in your browser — the simplest on-ramp, what it's great at, and the copy-paste friction that eventually pushes people elsewhere. beginner 8 min
  2. AI inside your editor Autocomplete plugins and AI-native editors that see your code as you type — the productivity jump, and the new failure modes that come with it. beginner 9 min
  3. Agentic & command-line tools Tools that read your repo, run commands, and edit files on their own — what an agent can do, and the guardrails you need before you let it. intermediate 10 min
  4. App, IDE, agent — or all three? There's no single right answer — how to match the integration method to the task, and why most people end up using more than one. intermediate 8 min

Module 4 — Modes of AI-Assisted Coding

The full spectrum, from a model finishing your line to a model building a feature unattended — what each mode is good for, and where it bites.

  1. Code & "sentence" completion The inline grey-text suggestions that finish your line or block — how they work, where they shine, and why they rarely lead you far astray. beginner 8 min
  2. Chat-assisted coding Conversation as the interface — generate, explain, refactor, and debug with a human in the loop reviewing every step. beginner 9 min
  3. Agentic coding & "vibe coding" Handing the model the wheel — autonomous plan-and-act loops and full "vibe coding", the productivity ceiling they raise, and the risks of trusting output you never read. intermediate 11 min
  4. Choosing where on the spectrum to work Completion, chat, agent, vibe — a single spectrum of how much you delegate, how to pick per task, and why every mode still ends in verification. intermediate 9 min

Module 5 — Directing How the Model Writes Code

Going from random results to reliable ones: prompting well, steering behavior with skills and config files, feeding the right context, and deciding between one model and many.

  1. Prompting for code What separates a vague request from one that gets the code you wanted — context, constraints, examples, and iterating instead of restarting. beginner 9 min
  2. Skills & AI config files Standing instructions that steer a model every time — skills, rules, and config files like CLAUDE.md and AGENTS.md — so you stop repeating yourself and get consistent code. intermediate 10 min
  3. Feeding the model the right context The model only knows what it can see — open files, repo retrieval and RAG, and tool/MCP connections — and how managing context decides the quality of the answer. intermediate 10 min
  4. One model, or a combination? Standardizing on a single model versus routing each task to the best tool — the case for each, and how multi-model setups actually work in practice. intermediate 9 min

Module 6 — Putting AI to Work in Your Projects

Everything applied: choose your model and provider, pick your method, keep the output trustworthy and safe, and start using AI in a real project today.

  1. Choosing your model & provider A repeatable framework for picking a model and provider — or a deliberate combination — driven by your work, budget, and constraints rather than the hype cycle. intermediate 10 min
  2. Choosing your method App, IDE, agent, or a blend — matching how you reach the model to how you actually work, and assembling a setup you'll stick with. intermediate 9 min
  3. Verifying AI-written code AI writes plausible code, not always correct code — reviewing it, leaning on tests, catching hallucinations, and the discipline that keeps speed from costing you quality. intermediate 10 min
  4. Security, privacy & ethics Where your code and prompts go, the licensing and IP questions, leaking secrets, the security of AI-written code, and using these tools responsibly. intermediate 9 min
  5. Getting started today Turning the whole path into action — concrete first steps for a real project, a worked example, and a look ahead to building AI into the software you ship. advanced 10 min
  1. Glossary of AI-for-development terms Plain-language definitions for every term in the learning path — token, context window, RLHF, embedding, RAG, MCP, agent, vibe coding, and more — cross-linked to the lessons.