Building with Claude: From First Prompt to Production

Deepak Mishra

7 min read

·

8 hours ago

--

Listen

Share

A practitioner’s series on prompting, the API, Claude Code, agents, and shipping real applications

Press enter or click to view image in full size

Here is the roadmap for review. I checked it against Anthropic’s current docs, and a few findings shape the plan:

• Model lineup. The docs currently list Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5 and Claude Haiku 5.5, and recommend starting with Opus 5.5 for most workloads and using Fable 5.1 for demanding reasoning and long-horizon agentic work. claude
• Context and effort. Context windows reach 1M tokens, and each model has a default effort level, so effort tuning is now a core topic rather than an advanced one.
• Managed Agents. Claude Managed Agents is a beta, Anthropic-hosted surface for server-managed stateful agents, with hosted tool execution, persistent agent configs and per-session sandboxes. Every Managed Agents API request needs the managed-agents-2026-04-01 beta header, which the SDK sets automatically. claudeclaude
• Skills. Agent Skills are packaged as SKILL.md files with instructions, descriptions and optional resources, and Claude invokes them on its own when relevant. claude

To keep the titles stable, no Part title names a specific model version. Version-specific details live inside the articles, and I’ll re-verify them before writing each Part.

The running capstone: Scout

Scout is a technical research assistant for an engineering team. It takes in specs, PDFs and tickets. It answers questions with citations and extracts structured data. It calls tools, connects to company systems through MCP, and runs as an agent that writes reports in house style. Each Part adds one capability, and Part 16 deploys it with evals, guardrails and a cost budget.

I picked a research assistant because it naturally uses almost every feature in the series (documents, tools, structured output, agents, a UI) without needing domain expertise from the reader.

Track 1 — Foundations

Part 1 — Meet Claude: Models, Surfaces and a Working Mental Model

What Claude is, where it runs, and which model to reach for

• Outcomes:
• Explain the model tiers and the cost/speed/capability trade-off between them.
• Tell the apps, the API, Claude Code and cloud platforms apart.
• Know Claude’s strengths and its honest limits.
• Prereqs: None.
• Hands-on: Run the same three tasks (summarise, reason, code) on different tiers and record the quality, latency and cost in a comparison table.
• Scout: Write Scout’s one-page product spec with Claude in the app.

Part 2 — What Happens When You Hit Send: Tokens, Context and Thinking

Context windows, adaptive thinking, effort, and why models get things wrong

• Outcomes:
• Reason about tokens and context budgets.
• Understand adaptive thinking and the effort parameter.
• Recognise hallucination, knowledge-cutoff and refusal failure modes.
• Prereqs: Part 1.
• Hands-on: Use the token-counting endpoint to measure inputs. Compare answers and costs at different effort levels on one hard question.
• Scout: Set Scout’s context budget and pick a default model and effort.

Track 2 — Prompting & Design

Part 3 — Prompt Engineering That Survives Real Users

System prompts, structure, examples, and testing prompts rather than admiring them

• Outcomes:
• Write system prompts that hold up.
• Use XML-tagged structure and few-shot examples.
• Control format and tone, and version your prompts.
• Prereqs: Part 2.
• Hands-on: Run a before/after prompt comparison on 10 test inputs and score both versions in a spreadsheet. This is a first taste of evals.
• Scout: Write Scout’s v1 system prompt.

Part 4 — Designing with Claude: Artifacts, Mockups and Front-End Code

Using Claude as a design partner, from rough idea to working UI

• Outcomes:
• Iterate on UI with artifacts.
• Give design direction that avoids generic output.
• Turn a mockup into clean HTML/React.
• Know where Claude’s design work needs human judgement.
• Prereqs: Part 3.
• Hands-on: Design Scout’s chat-and-citations interface across three iterations, then export working front-end code.
• Scout: Scout’s UI shell.
• Flag: Some design and artifact features depend on your plan.

Track 3 — Building with the API

Part 5 — Your First Real Integration: Messages API, SDKs and Streaming

From an API key to a streaming multi-turn chat, done properly

• Outcomes:
• Set up the Console and SDKs.
• Understand the message structure and multi-turn state.
• Stream responses.
• Handle errors, retries and rate limits.
• Prereqs: Basic Python or TypeScript.
• Hands-on: Build a streaming CLI chat in Python, with a TypeScript version alongside.
• Scout: Scout’s backend core.

Part 6 — Tool Use from First Principles

Teaching Claude to call your functions, and designing tools it uses well

• Outcomes:
• Understand tool definitions, the tool-use loop and tool_choice.
• Handle parallel tool calls.
• Use the SDK’s Tool Runner.
• Use server tools such as web search and code execution.
• Design good tool descriptions.
• Prereqs: Part 5.
• Hands-on: Write a hand-rolled agent loop, then refactor it onto Tool Runner.
• Scout: Scout gains search, a calculator and a ticket-lookup tool.

Part 7 — Structured Outputs and Reliable Extraction

Getting JSON you can trust into typed code

• Outcomes:
• Use schema-constrained structured outputs.
• Integrate with Pydantic and Zod.
• Add validation and repair strategies.
• Know when to use structured outputs and when to use tool calls.
• Prereqs: Part 6.
• Hands-on: Extract requirement fields from messy spec text into typed records, and measure the failure rate.
• Scout: Scout’s extraction pipeline.

Part 8 — Real Documents: Vision, PDFs, Files and Citations

Working with the inputs people actually have

• Outcomes:
• Use image and PDF input.
• Upload once and reuse with the Files API.
• Get grounded answers with citations.
• Handle large documents within context limits.
• Prereqs: Part 7.
• Hands-on: Build a Q&A over a set of PDFs with clickable citations.
• Scout: Scout answers from documents with sources.

Part 9 — Fast and Cheap: Prompt Caching, Batches, Effort and Model Routing

Cutting cost and latency with measurements, not guesswork

• Outcomes:
• Design prompts so caching hits.
• Use the Batch API for offline work.
• Route requests between tiers.
• Tune effort for cost.
• Build a simple cost model.
• Prereqs: Parts 5–8.
• Hands-on: Take a before/after cost and latency benchmark on Scout’s workload.
• Scout: Scout gets a cost dashboard.

Track 4 — Coding with Claude

Part 10 — Claude Code as a Teammate: CLAUDE.md, Workflows, Reviews and Refactors

Agentic coding without losing control of your codebase

• Outcomes:
• Install Claude Code and set permissions.
• Use plan mode.
• Write a CLAUDE.md file.
• Use custom commands, hooks and subagents.
• Run code review and GitHub workflows.
• Know when Claude Code goes wrong.
• Prereqs: Git and a terminal.
• Hands-on: Use Claude Code to restructure Scout into a tested package, and record the session.
• Scout: Scout’s codebase, with tests and CI.

Track 5 — Agents & Integrations

Part 11 — MCP: Connecting Claude to Your Tools and Data

One protocol, many clients, and the security model that comes with it

• Outcomes:
• Understand MCP concepts: servers, tools, resources and prompts.
• Build a server with the Python SDK.
• Use that server from Claude Code, the apps and the API’s MCP connector.
• Apply trust and permission rules.
• Prereqs: Part 6.
• Hands-on: Expose Scout’s knowledge base as an MCP server.
• Scout: Scout becomes reachable from any MCP client.

Part 12 — Agent Skills: Packaging Expertise Claude Loads on Demand

SKILL.md, progressive disclosure, and when a Skill beats a prompt or a tool

• Outcomes:
• Write a Skill.
• Structure multi-file Skills.
• Use Skills across the apps, Claude Code, the API and the Agent SDK.
• Test that a Skill triggers when it should.
• Prereqs: Parts 10–11.
• Hands-on: Write a scout-report Skill that produces reports in house style.
• Scout: Scout’s reporting capability.

Part 13 — Building Agents: Agent SDK, Managed Agents and Multi-Agent Patterns

From a loop you write yourself to hosted agents, and when not to use an agent at all

• Outcomes:
• Understand the anatomy of an agent loop.
• Use the Agent SDK’s query(), subagents and permissions.
• Know when Managed Agents fit, and their beta status.
• Apply orchestrator–worker patterns.
• Control agent failure modes.
• Prereqs: Parts 6, 11 and 12.
• Hands-on: Build Scout as a research agent that plans, gathers evidence and files a report, once with the Agent SDK and once with Managed Agents, then compare the two.
• Scout: Scout goes autonomous.
• Flag: Managed Agents is in beta.

Track 6 — Production

Part 14 — Evals: Knowing Whether a Change Made Things Better

Test sets, graders, and surviving model upgrades

• Outcomes:
• Design an eval set.
• Use code-based and model-graded scoring.
• Run regression checks on prompt or model changes.
• Run evals in CI.
• Prereqs: Parts 3 and 7.
• Hands-on: Build Scout’s eval harness, with a pass/fail gate in CI.
• Scout: Scout’s quality baseline.

Part 15 — Guardrails, Safety and Observability

Prompt injection, tool permissions, PII, tracing and fallbacks

• Outcomes:
• Model injection threats for tools and agents.
• Apply least-privilege tools and human-in-the-loop approval.
• Handle PII.
• Add logging and tracing.
• Monitor usage and cost.
• Degrade gracefully when things fail.
• Prereqs: Parts 11, 13 and 14.
• Hands-on: Red-team Scout with injected documents, then fix what breaks.
• Scout: Scout is hardened.

Track 7 — Capstone

Part 16 — Shipping Scout: An End-to-End Production Deployment

Architecture, deployment, budgets, and a model-migration playbook

• Outcomes:
• Lay out a reference architecture.
• Choose a deployment target: a container, edge, or cloud platforms such as Bedrock, Google Cloud or Foundry.
• Set latency and cost budgets.
• Plan rollouts.
• Upgrade models without regressions.
• Prereqs: The whole series.
• Hands-on: Deploy Scout publicly and run a production readiness checklist.
• Scout: Shipped, followed by a candid retrospective.