From Frontend Engineer to Agent Engineer in 30 Days

LLM API Basics: messages/roles, Tokens, Streaming, Temperature; What an Agent Actually Is

Starting from messages/roles, tokens, streaming, and temperature, get clear on what an LLM API actually does, and what an agent has that a plain chat doesn't.

How Tool Calling Works: JSON Schema, the tool_use Loop; Hand-Writing an Agent Loop With No Framework

With no framework at all, hand-write an agent loop that can call tools, and fully understand what actually happens behind function calling.

Getting Started With the Pi SDK: the Three-Layer Architecture, Comparing It to the Agent Loop (dg P01/P02/M02/M03)

Rewrite day two's hand-written agent with the Pi SDK, compare it against the three-layer architecture and the Agent Loop in the source, and see what the framework does for you.

Model Integration and System Prompts: a Multi-Provider Abstraction With Fallback, Overriding the Default Persona (dg P03/P04/M04)

Learn to abstract multiple model providers behind one layer with automatic failover, and understand why you must override the framework's default system prompt.

The Tool System and Event-Driven Design: Parameter Validation, Feeding Errors Back for Self-Correction, Event Subscription (dg P05/P06/M05/M07)

Make the tool system solid: validate parameters, feed errors back to the model so it can correct itself, then use event subscription to expose the agent's internal state to an outside interface.

Messages, Context Engineering and Compression, Session Storage/Recovery/Forking (dg M06/M08/M09/M10)

Understand how messages are organized and passed around inside an agent, how to compress context once the window fills up, and how a session is persisted, recovered, and forked.

Packaging It as a Service: Fastify + SSE + Docker (dg P07); Week One Retrospective

Package the agent built over the previous six days into a Fastify service other frontends and services can call, streaming output over SSE and packaged with Docker, wrapping up week one.

Why Split Gateway and Worker; Postgres Table Design (sessions/runs/messages) + Drizzle

Understand why a production-grade agent splits its intake layer from its execution layer, and use Drizzle to create mini-koda's first batch of tables.

A Redis Streams Message Bus: XADD/XREADGROUP/XACK/XAUTOCLAIM, Consumer Groups, Poison Messages

Build a message bus with Redis Streams, understand how a consumer group lets multiple workers split consumption, and handle a "poison message" that keeps failing.

Sharding and Leases: Hashing userId → shard, SET NX + TTL + Lua Renewal, Per-User Ordering, Handoff

Use hash-based sharding to spread user traffic across multiple workers, then implement lease renewal with Redis's SET NX + TTL + a Lua script, guaranteeing a single user's messages are processed in strict order.

The Run State Machine, Streaming Output Back, Ordering by runId, SSE Waiters, Merging Interruptions Within 30 Seconds

Build a run state machine for every conversation turn, stream the worker's output back in order by runId to the waiting SSE connection, and merge interruptions that arrive within 30 seconds.

Long-Term Memory: pgvector, Embeddings, Chunking, the memory_search Tool

Give the agent long-term memory with pgvector: chunk historical content, generate and store embeddings, then wrap it into a memory_search tool the model can call.

Cron Scheduling (Central Scheduler → Stream Delivery) + Cost Metering (Token → USD Ledger, Usage Report)

Implement a centralized cron scheduler that delivers scheduled tasks into the message bus, and build a cost-metering system that converts token usage into a USD ledger.

Deployment and Operations: Multi-Worker Compose, Heartbeats, Health Checks, Graceful Shutdown, Dev/Prod Isolation; Week Two Retrospective

Run mini-koda as a multi-worker deployment with docker compose, add heartbeats, health checks, and graceful shutdown, sort out how dev and prod stay isolated, and wrap up week two.

A Tour of Multi-Agent Patterns (Router/Supervisor, Planner-Executor, Critic, Swarm, Blackboard) and When Not to Use Them; Getting Started With LangGraph

Get acquainted with the common patterns for multi-agent systems, get clear on when a single agent is enough and when you actually need multiple agents, and build your first three-node graph with LangGraph.

Dynamic Routing With a Supervisor: Structured-Output Routing, Override, routingReason

Implement a supervisor node that uses structured output to dynamically decide which subagent to route to, and support human override plus recording the reason behind each routing decision.

Planner-Executor-Critic Plus a Shared Workspace: Workspace State, toolBudget, Parallel Fan-Out, a Review Loop

Build a Planner-Executor-Critic collaboration flow, pass intermediate state through a shared workspace, add a tool budget and parallel execution, then have the Critic check the result and drive a rewrite.

History Fidelity and Summarization, Multimodal Placeholders, Checkpointer Persistence

Keep a long conversation's history from getting distorted inside a multi-agent graph, add a summarization node that compresses early content, and persist execution state with a checkpointer.

Cross-Service Agent Integration: Minting a User-Level JWT, JWKS Signature Verification, the inject/memory/usage Interfaces, Idempotent externalId

Connect the mini-multi-agent service to mini-koda: mint a user-level JWT, verify signatures with JWKS, and integrate the inject, memory, and usage interfaces while guaranteeing idempotency.

Scheduled Jobs and Proactive Outreach: Time Zones, Quiet Hours, Daily Caps, a Notification Provider Abstraction

Implement a scheduled job that proactively messages users: handle time-zone conversion, quiet hours, and a daily send cap correctly, and abstract the notification channel behind a swappable provider.

Evaluation and Observability: a Golden Set, LLM-as-Judge, Tracing, a Failure-Rate/Cost Dashboard; Pi vs. LangGraph Summary; Week Three Retrospective

Build an agent evaluation system: score with a golden set and LLM-as-judge, wire in tracing and a failure-rate/cost dashboard, and summarize when Pi and LangGraph each fit, wrapping up week three.

Security: Prompt Injection, Least Privilege for Tools, Sandboxing Approaches, Secret Management

Get acquainted with common prompt-injection attack techniques, lock tools down to least privilege, understand sandboxing approaches, and set proper conventions for managing secrets.

MCP and Skills: the Protocol, Server/Client, How It Differs From Function Calling; a Tour of the Claude Agent SDK

Get acquainted with the MCP protocol's server/client structure and how it differs from plain function calling, write a minimal MCP server and wire it into an agent, then take a quick tour of the Claude Agent SDK.

RAG, Level Up: Hybrid Search, Reranking, Citations, Recall Evaluation

Upgrade day twelve's memory retrieval into a hybrid-search-plus-rerank combination, add source citations, and evaluate retrieval quality with a recall metric.

The Frontend Agent Experience: Streaming Rendering, Visualizing Tool Calls, Interrupt/Retry, SSE Hooks

Write a React chat frontend for mini-koda: render the reply as it streams in, visualize the tool-calling process, and support interrupting and retrying.

System Design Deep Dive: Agent Platforms / Customer-Support Agents / Multi-Tenancy / Cost Control

Prepare an interview-ready answer template for each of four frequently asked system-design topics: agent platforms, customer-support agents, multi-tenancy, and cost control.

Resume and Project Packaging: STAR, README, Architecture Diagrams, a Demo Video, an English Resume

Use the STAR method to turn three repos into resume highlights, round out each with a README and an architecture diagram, record a demo video, and produce an English resume.

Mock Interview Day: One Full China-Domestic-Style and One Full Overseas-Style Round, Self-Assessment

Run through one complete mock interview in China's domestic style and one in the overseas style, score yourself with a rubric, and list the weak points to prioritize next.

Shoring Up Weak Points + a Coding Warm-Up: Rate Limiter, LRU, Concurrency Control, Streaming JSON Parsing

Do targeted work on the weak points listed on day 28, while warming up on four frequently asked coding problems: a rate limiter, an LRU cache, concurrency control, and streaming JSON parsing.

Full Retrospective and Application Kickoff: a Complete Pass Over the Interview Bank, a Knowledge Map, Month-Two Application Cadence, Public Launch of the Site

Go through the full 30-day interview question bank once, draw a knowledge map, set a cadence for month-two applications, and publicly launch this learning site.