AI Development & Programming: Build Apps with AI

You built RAG but the search quality is mediocre — that's exactly when reranking helps. Reranking re-scores the candidates roughly gathered by embedding (vector) search by their relevance to the query and reorders them, keeping only the top ones; this single step can dramatically change a RAG system's answer quality. This beginner guide covers what reranking is (a first-screening-and-final-interview analogy), why it's needed (embedding search vectorizes the query and documents separately, so it judges relevance only coarsely, and a bad ordering directly lowers answer quality — research shows reranking can substantially lift retrieval accuracy, and layering it onto hybrid search is the 2026 standard), how two-stage retrieval works ("gather wide" with fast embedding search for recall, then "narrow smart" with the reranker for precision, then hand the top to the LLM), why a reranker is more accurate (a bi-encoder vectorizes query and document individually and is fast but approximate; a cross-encoder feeds them in together and outputs a 0–1 relevance score, accurate but heavy — so you gather with the fast bi-encoder and narrow with the accurate cross-encoder), and the models and implementation (API type like Cohere Rerank, Voyage, and Jina; open-source like BGE reranker, mixedbread, and FlashRank; and LLM-based scoring like RankLLM — just retrieve 50–100 and narrow to the top 5). The principle: gather wide, narrow smart, and tune the counts with AI evals.

RAG, semantic search, and recommendations all rely on an unsung workhorse: the embedding (vector). An embedding is the meaning of text (or an image) converted into a sequence of numbers — a vector. The word "dog" becomes a list of hundreds to thousands of numbers that act as "coordinates of meaning," so words close in meaning sit near each other ("dog" and "puppy" are close; "dog" and "car" are far), and closeness is quantified with measures like cosine similarity. Famous example: "king − man + woman ≈ queen." Because of this, a machine can judge whether meaning is close even when the characters don't match. This beginner guide covers what an embedding is (a "map of meaning"), why closeness measures meaning (dimensions and cosine similarity), what it's used for (RAG, semantic search, classification and dedup, recommendations, and multimodal), how to choose an embedding model (API type like OpenAI text-embedding-3, Cohere, Gemini, Voyage; open-source like BGE-M3, Nomic, Qwen3; plus Matryoshka, which lets some newer models shrink dimensions afterward — e.g. OpenAI's 3,072 down to 1,024, giving up a little accuracy for about a third of the storage), and vector DBs (Pinecone, Weaviate, Qdrant, Chroma, pgvector) with a three-step start (pick a model, vectorize and store documents, vectorize the question and search). Embeddings are the foundation of implementing RAG.

You refined your prompts, added knowledge with RAG, and maybe fine-tuned — so how do you confirm it actually got better? AI evals take center stage, and by 2026 evaluation is so essential it is called "infrastructure." AI evals mean systematically measuring an LLM's output quality (accuracy, hallucinations, format adherence, tone) on a fixed yardstick instead of by gut feel; without them, improvement is just a hunch. There are two methods: code-based evaluation for mechanically measurable items (exact match, format, required/banned words — fast, cheap, stable) and LLM-as-judge for subjective ones (using a powerful LLM as a referee to score outputs, via pairwise comparison or single-output scoring). The principle: measure with code whatever code can measure. LLM-as-judge has verbosity, position, and self-preference biases; the fixes are using a different family of model as grader, swapping order and grading twice, putting conciseness in the rubric, and calibrating against human judgment. Coarse scales (pass/fail or 1–3) are often recommended over fine-grained 1–10. In practice, run three tiers — instant code checks on every change, nightly LLM-judge regression tests, and continuous production monitoring — using tools like DeepEval, Promptfoo, and RAGAS for CI plus Braintrust, LangSmith, and Arize for monitoring. Start by gathering 10 good and 10 bad outputs and scoring them.

Fine-tuning trains a pretrained model's weights or added adapters to adjust its style, classification, and output tendencies. This guide compares it with RAG and prompting, explains full fine-tuning, LoRA, and QLoRA, and covers data quality, evaluation, and training and inference costs. It also explains that OpenAI's self-service fine-tuning no longer accepts new users and sets out the conditions for existing users, then walks through a classification example from pre-run checks to an adoption decision.

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), the basic four steps (Specify → Plan → Tasks → Implement), the main tools (GitHub Spec Kit with 140,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 Anthropic's 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% 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 won't 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 as of June 2026 (Opus 4.8 by default, escalate the hardest 10-20% to Fable 5, terminal work to GPT-5.5, switchable by model ID; read Opus 4.8 as the Opus 5 family today), 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 (today the Opus 5 family) 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 stops a self-paced loop and fixed intervals are cancelled, session-scoped so a new conversation clears it, closing the terminal stops it unless the session is sent to the background with /background, 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.

Anthropic says enterprise Claude Code usage averages $150–250 per developer per month, and running agents in parallel for long stretches can go well beyond that. But just by changing how you use it, you can cut cost substantially without lowering output quality. This guide first unpacks the true face of high cost (expensive model, long context, wasted calls; how token billing works; agent teams using about 7x a standard session), then the subscription vs. API break-even (API billing only comes out cheaper for very light use, a few times a month; if you code daily, a subscription almost certainly wins), a pricing overview (Copilot Pro $10 / Cursor Pro $20, Pro+ $60 for daily agent use / Claude Pro $20, Max $100; Copilot moved to usage-based AI Credits on June 1, 2026), six levers to cut cost (① model routing ② prompt caching at about 90% off ③ 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 our beginner's guide to RAG, 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 plus reranking, which Anthropic reports cut top-20 retrieval failures by 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 (~$20-$60/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.