AI agent development is applied software engineering, not machine learning research. You need strong programming fundamentals and the specific skill of getting reliable, structured output from a model — not a PhD in mathematics.
Core concepts
- Python fundamentals: The default language for agent frameworks — OpenAI Agents SDK, Pydantic-AI, smolagents, Strands, and LangChain/LangGraph are all Python-first. Python Docs
- Async Python: Agent loops make repeated model and tool calls;
asyncio,async/await, and concurrent tool execution are used constantly in every framework's real-world examples. Real Python: Async IO - TypeScript/JavaScript: The second language worth knowing — Vercel AI SDK, the OpenAI Node SDK, and most web-facing agent products (chat widgets, voice agents) are TS-first. Vercel AI SDK Docs
- Prompt engineering fundamentals: Zero-shot vs few-shot prompting, chain-of-thought, and structured-output prompting are the base skill every framework assumes you already have. Anthropic: Prompt Engineering
- Working with structured output: Getting a model to reliably return JSON matching a schema — via Pydantic models, Zod schemas, or native structured-output modes — underpins every tool call you'll ever write. OpenAI: Structured Outputs
- REST APIs & webhooks: Agents live or die by how well they integrate with real systems — most tools you give an agent are thin wrappers around a REST API.
What Is It?
This chapter lists software foundations for agent developers: languages, async, APIs, structured outputs, and testing habits.
Each linked unit is a mini learning path with projects framed through an agent lens.
You are learning to build systems that call models, not to train foundation models from scratch.
Why Should I Care?
Tool loops are just HTTP, retries, parsing, and state — boring code that must be correct.
Hiring managers still filter on Python/TS fluency even when the title says 'AI'.
Real World Analogy
Calling an LLM without coding fundamentals is like driving a Tesla without knowing where the brakes are — smooth until something unexpected appears.
Visual Mental Model
Python/TS basics
-> HTTP/JSON
-> async I/O
-> structured outputsBeginner Explanation
Solid Python (or TypeScript), async HTTP, JSON, and typing/validation libraries underpin every agent SDK. Prompting sits on top of this, not instead of it.
Smallest Possible Example
import httpx
async def ping(url: str) -> int:
r = await httpx.AsyncClient().get(url)
return r.status_codeCommon Mistakes
❌ Copy-pasting agent SDK samples without reading async errors.
Hidden blocking calls stall your whole loop under load.
❌ Trusting model JSON without validation.
Use Pydantic or schema checks before acting on tool args.
❌ Ignoring git because 'it's just prompts'.
Prompts and tool manifests are production config — version them.
Real Project Example
FastAPI services wrap agent runners at many startups.
TypeScript agent SDKs from OpenAI target full-stack teams shipping on Node.
Build This Mini Project
Write an async function that fetches JSON from an API, validates one field with Pydantic, and logs structured output.
Interview Question
Why Python for agents?
Most agent SDKs, notebook tooling, and ML-adjacent libraries are Python-first; async HTTP and validation ecosystems are mature; teams iterate quickly — TS is the common second language for web-facing agents.
Key Takeaways
- Agents are applied software engineering.
- Async HTTP + validation are daily tools.
- Learn prompting after code basics.
- Use chapter units as spaced practice.
Resources
YouTube learning
Core concepts from video walkthroughs:
The 60-second story
You are hiring a small office. The work is not “be clever in a chat box.” The work is: read a request, call a system, check the reply, try again. Python is the office most agent kits already moved into. The OpenAI Agents SDK, Pydantic-AI, smolagents, Strands, LangGraph — the lights are already on in that language. Learning Python here is not a detour. It is showing up to the building where the tools hang.
Async is the difference between a clerk who stares at the hold music and a clerk who files something else until the model or the API speaks. Agent loops are mostly waiting: model, tool, model, tool. If each wait freezes the process, one user owns the office.
TypeScript is the second desk, closer to the website. Chat widgets, Vercel’s AI SDK, a lot of product UI — that desk speaks JavaScript with labels. You do not need to betray Python. You need to recognize the same loop wearing a different badge.
Prompting is how you brief the new hire on day one. Zero-shot is “you know this job.” Few-shot is “here are three good tickets.” Structured output is “do not write me an essay; fill this form.” Every tool call you will ever trust starts as a form, whether the form is a Pydantic model, a Zod schema, or the provider’s structured mode.
REST and webhooks are the loading dock. Most “tools” are a thin coat around an HTTP call. If the dock is sloppy, the brilliant hire just sends the wrong crate faster.
Map the office.
- Python is the main floor.
async/awaitis not staring at hold music.- TypeScript is the desk that faces the product.
- A prompt is the brief.
- Structured output is a form, not a paragraph.
- A tool is often a REST call in a jacket.
- A webhook is the loading dock calling you back.
async def handle(user_text: str) -> dict:
return {"reply": user_text.strip(), "ok": True}Tiny, and it already shows the two habits: the function can pause later, and the result has a shape. When you swap the body for a model call, the shape should stay.
These skills sit under every framework because the frameworks assume them. A kit cannot teach you what a form is and also be the thing that retries the form. People skip this page, install a framework, and then debug a string they wish was JSON.
Mental model: an office where the brief is a form and the phone calls are allowed to wait. Python runs the floor. Types keep the form honest. Async keeps one call from closing the office.
If you can say “the model fills a form, the tool hits an API, and the loop should not freeze while it waits,” you have the foundation the rest of the roadmap stands on.
