Three angles on the current generation of AI - the assistant most teams build on, the design tool from the same lab, and the engineers worth following as the agentic field evolves.
The agent slice walked in full - the idea, the window, the extensions, the architectures, production, and the frameworks - with three reading orders for different readers.
Read it →One page that ties the AI library together - every article outside the agent layer sorted by layer (foundations, models, platforms, protocols, retrieval, tools), a hand-off to the Agentic AI stack, and four reading orders.
Read it →Answer engines write you a paragraph instead of ten links - but crawl, index, and rank still run underneath. What retrieval-augmented generation changes, and what it leaves exactly where it was.
Read it →An 800-page document and one question: why pasting it all into the prompt fails, and how retrieval-augmented generation finds the few pages that matter instead. What it costs to build, and what the prompt looks like; the internals are in Inside a RAG pipeline.
Read it →Chunking, embeddings, cosine similarity, BM25, and rank fusion - each part of the retrieve step taken apart one at a time, and the failure modes that decide how you tune it.
Read it →Not rivals - a pattern and a protocol. The real choice is who triggers retrieval: your code before every call, or the model through a tool. The axes that decide it, and the shape most teams end up with.
Read it →The AI pair programmer that lives inside your editor - inline completions, a chat sidebar, agent mode, and a model picker that now spans OpenAI, Anthropic, and Google.
Read it →The two AI pair programmers most developers reach for today - one in the editor, one in the terminal. How they differ, when to pick which, and why a lot of teams use both.
Read it →The focused essay on the one axis that most decides which AI pair programmer fits which task. One tool ships clean parts; the other proposes whole designs.
Read it →The six things sitting in the window on any given turn, what each one costs, and what gets thrown away when it fills up.
Read it →Context, state, long-term memory, and retrieval - the four words builders keep merging, separated, placed on one diagram, and given the one design decision each of them needs.
Read it →The learned "brain" of an AI system - patterns learned from data, applied to new input. The data-to-output chain, a worked translation example, what the file is made of, and four things a model is not.
Read it →One kind of AI model - very large, trained on text, predicting what comes next. What the three words in the name mean, what the model is actually doing, why it invents things, and why it cannot remember yesterday.
Read it →One question - what is the capital of the UK? - followed from keystroke to answer: the template, the tokens, attention, the probability table, and the loop that runs again for every word.
Read it →The umbrella term - software that composes new text, code, images, audio, and video instead of labelling what exists. How it works, the modalities, where LLMs and agents fit, what it is good and bad at, and the three ideas that made it possible.
Read it →A confident, fluent, false answer is not a malfunction - it comes from the same process as every correct one. The mechanism, the forms it takes (facts, citations, code, agent reports), where it clusters, and how to build a product that catches it.
Read it →One word, four things it gets added to - a person, a training set, a product, or a model's prompt. Human, data, and AI augmentation, plus RAG, with the two questions that tell them apart.
Read it →Why a run costs many times what its prompt suggests, where the money goes, and the gap between an agent that works and one you can afford to run every day.
Read it →Orchestrator-workers, pipelines, fan-out, critique, routing - the five ways production systems wire agents together, and how to pick the least dynamic one that fits.
Read it →The move from one agent that does everything to several that each do one thing well - why teams make it, and what the handoffs cost.
Read it →A chatbot answer is one artifact you can read. An agent run is twenty hidden steps and a confident summary - what to measure, and how to catch quality sliding rather than breaking.
Read it →The failure modes that only show up once an agent leaves the demo - runaway loops, exhausted context, compounding errors, and the one that costs most: a run that reports success on work it never did.
Read it →Model, tools, loop - the strict definition, how an agent differs from a chatbot and from a workflow, one task traced end to end, and the ten-line loop that runs it.
Read it →A short, honest tour of the term everyone is using - what agentic AI actually means, how it differs from a chatbot, the loop that powers it, and where it earns its keep in real work.
Read it →Portable, composable units of expertise an agent can load on demand - the way you teach Claude (or any modern LLM agent) to do specialised work without rebuilding the model around it.
Read it →Anthropic's AI assistant - a family of large language models built for conversational reasoning, writing, coding, and analysis, with safety as a first-class design goal.
Read it →Claude Academy's free catalog after the August 2026 move off Skilljar - every course with its lesson count, hours, and badge, grouped as the Academy groups them, and where to start in it.
Read it →Anthropic's coding agent that runs in your terminal - reads your codebase, edits files, runs commands, and ships features. Claude with your shell at its disposal.
Read it →Anthropic's agent for knowledge work - hand it a goal and it plans and runs the multi-step task across your files and tools, returning a finished deck, doc, sheet, or brief. Same engine as Claude Code, no terminal.
Read it →Two agents, one engine, two jobs - knowledge work versus software engineering. Where each lives, what it acts on, what it hands back, and how to tell which a task belongs to.
Read it →Bundle skills, MCP connections, hooks, and agents into one installable unit - what a plugin is made of, how a marketplace serves it, and how install and updates actually work.
Read it →The building blocks you extend an agent with - instructions it reads, live links to your tools and data, deterministic guardrails, and the plugin that bundles them. One overview, with links to the deep dives.
Read it →A real 2018 snake game - ASP.NET Core, gulp, .cshtml, scattered JavaScript - migrated to HTML5 + TypeScript + esbuild in a single Claude Code session. Twenty minutes of work, screenshot by screenshot.
Read it →Describe what you want and an AI designer builds it as a working artifact - mockups, prototypes, and decks your whole team clicks, comments on, and changes in one place.
Read it →Microsoft's open-source framework for building agentic AI applications - the successor to AutoGen, with first-class C# and Python SDKs and an Azure AI Foundry integration.
Read it →The six frameworks teams reach for when they move from one-off prompts to real agents - LangChain, LangGraph, CrewAI, AutoGen, Semantic Kernel, and Microsoft Agent Framework, lined up side by side.
Read it →The open standard for connecting AI assistants to the tools and data they need - one protocol every model speaks, one server every host can plug into.
Read it →Three building blocks people keep mixing up - the unit of action, the protocol that plugs it in, and the folder of know-how that tells the agent when to use it.
Read it →Google's image generation model - real-time, conversational image creation inside Gemini, the Gemini API, and the wider Google creative stack.
Read it →The capability tour - vibe edits, style transfer from a reference, legible in-image text, infographics on Pro, and the Fast / Thinking / Pro speed picker.
Read it →OpenAI's image model family - gpt-image-2 and its siblings, the two APIs that reach them, and what each quality knob actually costs.
Read it →The plain markdown file Claude Code reads at the start of every session - what belongs in it, where the four scopes live, how they load, and how it differs from auto memory.
Read it →Two separate products behind one sign-in - an app your staff use and an API your software calls. What each one gives you, and why the seats you pay for include no API usage at all.
Read it →There is no Claude Business. The seat-based app tier, the developer platform behind it, and the four places Anthropic deliberately lets API billing cross into the subscription.
Read it →Four products, two shapes. The vocabulary translation table, how each vendor subdivides an organization, and the billing difference that decides who owns your coding-tool spend.
Read it →Anthropic's free learning hub, mapped by shape rather than by course list - what a course, tutorial, use case, and webinar each are, the five product areas, and why it is not the certification program.
Read it →The API, SDKs, and Console behind "the API" - three layers, one messages.create call, the agent loop you write yourself, and the managed agents that run it for you.
Read it →The Responses API, hosted tools, and Agents SDK behind "the API" - the same three layers and the same loop as the Claude article, with OpenAI's names on them.
Read it →Sampling, notifications, roots, and the two transports that carry them - the server-to-client half of MCP the 101 article leaves out, and why remote deployments quietly lose it.
Read it →The control loop taken apart one stage at a time - state, planning, tool selection, observation, recovery, termination, and the approval gate - and why an agent is not simply an LLM plus tools.
Read it →AI is not magic, it is a reflection - the four properties that make context good, the four ways it goes bad, and why pasting everything you have makes the answer worse.
Read it →Pretraining, fine-tuning, preference training, then a frozen file - plus where embeddings and vector databases actually sit, which is nowhere near the learning.
Read it →You changed the prompt - is the output better? The grader is the part of an eval that turns one output into a score, and the model grader is the kind that asks another model to do it. Code, human, or model, and when to trust the number.
Read it →The model never calls your API. It returns a request, your code runs the function, and the result goes back for the model to answer from. The four-step handshake, the schema the model actually reads, and where the loop ends.
Read it →The unit the model actually reads, and the unit you are billed in. Subword splitting from BPE to byte-level, the compression trick from 1994 behind it, and why counting the r's in strawberry is hard.
Read it →The 1994 compression trick that decides where your text breaks - the two runs behind every model, the merge loop that builds the vocabulary, and the three changes GPT-2 made to turn it into the default.
Read it →No cards match that combination.