AI Development & Programming: Build Apps with AI

When you want to customize AI for your own company, fine-tuning is one of the options — but dive in carelessly and it is costly and easy to get wrong. This beginner guide explains fine-tuning: taking an already-trained base model, training it further on data tailored to your use, and reshaping it into a specialized model that bakes "behavior" (house style, output format, domain phrasing) into the model itself by rewriting its weights. Fine-tuning is good at changing behavior but bad at memorizing up-to-date knowledge, so the rule is "facts and knowledge → RAG, personality and mold → fine-tuning, prompts first." As experts note, about 80% of "we need fine-tuning" is solved by better retrieval (RAG) or prompting, so order matters. The article covers what fine-tuning is (a new-hire-training analogy), what it is good and bad at, a fine-tuning vs RAG vs prompting comparison table, the main methods (full fine-tuning, LoRA, and QLoRA — 4-bit quantization that is light enough for beginners), what you need (500+ high-quality examples as a guide, with data-building the real work; costs from $5,000 to over $50,000, OpenAI fine-tuning at roughly $25–$100 per million training tokens; tools like OpenAI, Unsloth, Axolotl, and Hugging Face), and the order to start in. Fine-tuning is the last resort.

In an era where AI writes the code, the higher-value skill is shifting from "writing code" to "writing the spec" — and the practice that captures it is spec-driven development (SDD). SDD puts the spec at the center of the project as the source of truth, and an AI agent derives the design, breakdown, and implementation from it instead of coding right away. The key is that each step leaves a document (often Markdown) that the next step reads. This beginner-friendly guide covers what SDD is (the spec is canonical; code is a derivative), why it matters now (it prevents vibe coding's "three-month wall" of technical debt and requirements drift at the design stage — GitHub reports roughly an order-of-magnitude fewer "regenerate from scratch" cycles), the basic four steps (Specify → Plan → Tasks → Implement), the main tools (GitHub Spec Kit with 90,000+ stars and 30-plus supported agents, AWS Kiro with its Requirements → Design → Tasks flow and Auto router, plus BMAD, OpenSpec, Tessl, Google Antigravity, and Cursor), when to use it versus vibe coding (a hybrid: vibe to explore, spec-driven to ship, with mandatory human review), and how to try it today. In the AI age, the people who rise are those who can define precisely what to build, not those who write code fastest.

The center of gravity in working with AI is shifting from prompt engineering to context engineering. Borrowing Anthropic's definition, context engineering is "the set of strategies for curating and maintaining the optimal set of tokens (information) you hand the model during inference" — covering not just the prompt but everything in the context window: the system prompt, tools, conversation history, and external data. It matters because of "context rot": the more tokens you add, the more accuracy actually drops. Chroma's 2025 study tested 18 leading models (GPT, Claude, Gemini, and more) and every one degraded as input grew, with information in the middle of long contexts especially easy to overlook ("lost in the middle"). This beginner-friendly guide covers what context engineering is and how it relates to prompt engineering, why context rot happens (attention is a finite budget), what actually lives in the context, six core techniques (right-altitude instructions, tool curation, just-in-time retrieval, compaction/summary compression, external memory notes, and sub-agent isolation), how it relates to RAG and Claude Skills, and habits you can use today such as starting a new session when the topic changes and pasting only the key points. The core idea: keep only the smallest, highest-signal tokens.

Claude Fable 5, released June 9, 2026 as Anthropics first publicly available Mythos-class model, is examined here for coding only (the full release is covered separately). The short version: Fable 5 pulls away the harder the coding gets. It posts 95.0% on SWE-bench Verified and 80.3% on the tougher SWE-bench Pro (vs Opus 4.8 69.2% and GPT-5.5 58.6%), and 29.3% on the hardest FrontierCode Diamond (vs Opus 13.4% and GPT-5.5 5.7%, ~5x GPT), while Terminal-Bench 2.1 is a close race at 84.3% (GPT-5.5 stays competitive via Codex CLI). The article gives a three-point developer summary (strongest on hard problems / finishes in fewer turns / but pricey and wont stop), a side-by-side benchmark table and how to read it (the harder the benchmark the bigger the gap; terminal work is close), the effort-scaling property (low 11.5% to max 30.9%, while GPT-5.5 plateaus at 5-6%; the longer and more complex the task the larger the lead; five parallel agents reportedly hit a 60% hidden-test pass rate 3.2x faster than a single agent), what it is actually good at (large multi-file refactors, long autonomous agent runs, front-end from a screenshot, API design plus tests plus docs; Simon Willison rated the output several days worth while calling it slow and expensive at over $110 in 5.5 hours), weaknesses (~2x the price of Opus 4.8 at $10/$50, complex sessions of 500k-1M tokens, misjudges when to stop and keeps running, code-review precision trails Opus, safety classifiers fall back to Opus 4.8 on about 20% of Terminal-Bench trials, and a tendency to report tested without running), routing guidance (Opus 4.8 by default, escalate the hardest 10-20% to Fable 5, terminal work to GPT-5.5, switchable by model ID), and where to use it (Claude Code, GitHub Copilot, AWS Bedrock, Azure Foundry, Databricks, Anthropic API) with pricing, a 1M-token context, 128k max output, and the June 9-22 free window. Fable 5 for the heavy one-off, Opus 4.8 for most of the daily grind. Figures are quoted from Anthropic and third-party reports and are directional, scaffold-dependent.

"Tell me when the build finishes." "If CI goes red, fix it." "Watch the deploy every 5 minutes." Handing these stay-glued chores entirely to AI is what the /loop command, added to Claude Code in 2026, makes possible. This beginner guide explains that /loop is a session-scoped scheduler that runs a prompt or slash command repeatedly on an interval you set (or the AI sets), then covers the four ways to use it (① /loop 5m X = fixed cron interval ② /loop X = self-pacing where the AI judges the interval ③ /loop 15m = the built-in maintenance prompt ④ /loop = auto-maintenance), how to write intervals (number + unit s/m/h/d, minimum 1 minute, natural language like "every 2 hours," and you can loop a slash command: /loop 20m /review-pr 1234), the power of self-pacing (shorter waits when active, longer when quiet, between 1 minute and 1 hour, and — unlike plain cron — it auto-ends the loop once it judges the task done), practical recipes (CI/deploy watching, PR babysitting, long-build checks, reminders, branch auto-maintenance), how to stop it and the cautions (Esc to stop, session-scoped so a new conversation clears it, closing the terminal stops it, fixed intervals last up to 7 days, max 50 tasks per session, fires between turns with jitter, local timezone), how to choose among three scheduling features (/loop for in-session monitoring, Desktop scheduled tasks for resident local work, Routines for unattended cloud ops), and loop.md customization plus disabling via CLAUDE_CODE_DISABLE_CRON=1 — all based on the official docs (as of 2026). What /loop changes is the time axis of work you can hand to AI.

Will you be on the side AI takes the job from, or the side that wields AI to do the work of ten? In 2026 that is the fork for engineers. This article frames becoming an "AI-native developer" (building apps with LLMs, agents, RAG — distinct from researching models) as a buildable skill stack, not a PhD, in three layers: ① the unchanging foundation (Python as AI dev's main language, Git, command line, HTTP/REST/JSON — you still need basics in the age of AI-written code); ② the 5 core AI-native skills (prompt/context design, RAG as the backbone of enterprise agents, building agents, MCP as the de facto tool-connection standard, and eval design — plus cost optimization, guardrails, observability); ③ the edge most people miss — eval design and context engineering (being able to write evals is the biggest signal of "actually built with LLMs," and an AGENTS.md/CLAUDE.md plus a small eval set is the leap from "assisted" to "native"). It adds an 8–12 month roadmap (foundation → LLM API/prompting → build RAG without frameworks → agents + MCP → evals + deploy + publish), a portfolio strategy where deployed work beats a diploma, pitfalls (tutorial swamp, tool-hoarding, neglecting basics), and market/demand figures (US-based, large regional variation). The boundary is whether you use AI as a system.

"Last month's API bill… $1,800?" In 2026, seriously running Claude Code as an agent has been reported to hit $500–2,000 a month. But just by changing how you use it, you can cut cost 70–85% without lowering output quality (multiple real-world reports converge here). This guide first unpacks the true face of high cost (expensive model, long context, wasted calls; how token billing works; agents consuming about 7x a single session), then the subscription vs. API break-even (API wins roughly only under 50 sessions a month; one estimate puts subscriptions up to 36x cheaper for daily use), a pricing overview (Copilot Pro $10 / Cursor Pro $20, $60–100 when heavy / Claude Pro $20, Max $100; Copilot moved to usage-based AI Credits on June 1, 2026), six levers to cut cost (① model routing for 40–70% off ② prompt caching at about 90% off with a 60–80% hit rate ③ context management ④ choosing subscription vs. API ⑤ auditing duplicate subscriptions ⑥ memory features), a savings checklist you can run today, and pitfalls — false economy, hidden labor cost, duplicate billing, meter shock, over-trusting the cache — plus recommended setups by type. Optimization isn't being stingy; it's designing to pay the right amount for the right thing.

You know "what RAG is," but when you build one the answer comes out off — because it's still naive RAG: chop carelessly and do a plain vector search. As the implementation follow-up to article 030, this explains the 2026 practical RAG pipeline (smart chunking, embedding, vector DB, hybrid search, reranking) stage by stage: chunking strategies (recursive 512 default, semantic/structural/parent-child, Contextual Retrieval reportedly cutting retrieval failures up to 67%), choosing an embedding model (text-embedding-3-large, etc.), a comparison of six vector DBs (Chroma for prototyping, pgvector with Postgres, low-latency Qdrant, fully managed Pinecone, hybrid champion Weaviate, large-scale Milvus), hybrid search fusing BM25 + dense vectors with RRF, retrieve-then-rerank with a bi-encoder then cross-encoder (Cohere/Voyage/BGE/Jina), the LlamaIndex (retrieval) vs LangChain/LangGraph (control) split, why a 1M-token window doesn't replace RAG (lost in the middle, distraction), and productionization caveats like building an eval set first.

You know "what an AI agent is" — so how do you build one? In 2026, no-code lets you get a working agent running in an afternoon by drag-and-drop, and modern SDKs let you assemble a practical one in under 100 lines. As the practical companion to "what is an AI agent," this covers the anatomy (brain LLM + instructions + tools + memory + autonomous loop), the two paths (no-code vs code), the universal 5-step build framework (scope the problem, choose your base, write instructions, connect tools, test small), a no-code tool comparison (Dify for a complete platform, n8n for business integration, Flowise for prototyping, and the easiest Custom GPT/Gemini Gems/Claude Projects), a code framework comparison (solid Claude Agent SDK/OpenAI Agents SDK, complex-control LangGraph, role-coordination CrewAI), a concrete worked example (summarize support email then notify Slack), cost (~$10-$50/month platform plus model usage) and timeline guides, and pitfalls (don't over-scope, permissions and runaway control, beware PoC-only). For most people, building one with no-code first is the right move.

Claude Code suddenly stops with "log in again," "rate limit," "prompt is too long," "MCP won't connect" — and googling each one gets tedious. This is a practical reference that catalogs the errors you commonly hit, with the cause and the command to run for each. It starts with the three diagnostic commands to run first (claude doctor for full diagnostics, /status for active auth, /context for the context breakdown), then focuses on the four common families (usage/rate limits, context overflow, expired auth, MCP connection failures) with symptom→cause→fix-command tables across auth & login, usage/rate limits (Claude Code burns 10-100x the tokens of chat), context & tokens (prompt too long, compaction thrashing), server & model (500/529/timeout/model not found), install/PATH/update, network & proxy (ECONNREFUSED, TLS), MCP, permissions (deny beats bypass), and misc (thinking blocks 400, image/PDF, IDE). It ends with an error→fix cheat sheet and FAQ. Based on the official Claude Code docs (as of 2026): when stuck run the three diagnostic commands, and if it is not fixed, run claude update.

In 2026 the big four of AI coding tools came into focus — Cursor, Claude Code, GitHub Copilot, and Codex. But lining them up to crown one winner leads you astray, because the four are different types. This article first nails the key point — the type difference (Cursor = AI editor, Copilot = IDE-integrated plugin, Claude Code = local CLI agent, Codex = cloud async agent) — then covers what each tool really is, a same-axis spec table (type, entry and top pricing, models, context, strengths), how to read the 2026 shift from flat fees to "allowance + usage (credits)," picks by your type (ease = Copilot $10+, editor experience = Cursor, heavy multi-file work = Claude Code, async batches = Codex), the capable-developer staple of combining "one IDE-side + one terminal agent," and honest caveats about pricing and benchmarks — all based on official sources and multiple outlets.

You finish a feature in Claude Code and go to press "Create PR" when a red banner appears: "Could not check the pull request status. This information may be out of date." This is not a code defect — Claude Code simply reached out to GitHub to fetch the latest PR state and that one request failed, and it is usually a harmless sync delay. This article covers the exact meaning of the error, how Claude Code sees your PR (a query via the gh CLI, with a note that the internal implementation is undocumented), the 5 root causes (expired auth, no push/PR yet, network/proxy, insufficient scopes, transient), a 4-step diagnostic order starting from gh auth status, a command cheat sheet (gh auth login/refresh/pr status and more), how to tell when "may be out of date" is safe to ignore vs. when to act, the gh pr create workaround, a recurrence-prevention checklist, and an FAQ. The rule: suspect the GitHub connection before you suspect the code.