Dayward AIWeChat Mini Program
All courses

30 days · about 180 hours

From Frontend Engineer to Agent Engineer in 30 Days

For anyone with no AI background: four weeks from the LLM API all the way to multi-agent orchestration and a job-hunt sprint.

Sign in and link WeChat to share one free article per day across both platforms. Unlock more with rewarded videos in the mini program.

Start day one

By the end

Resume v1 plus three repo READMEs plus the site live

Working alongside dg-ai-notes, go from the LLM API all the way to the Pi SDK and get the principles of a single Agent nailed down

View account and linked status →30 days · about 180 hours

Week 1

Single-Agent Principles + the Pi SDK

01
D1🔒 Locked

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.

02
D2🔒 Locked

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.

03
D3🔒 Locked

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.

04
D4🔒 Locked

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.

05
D5🔒 Locked

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.

06
D6🔒 Locked

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.

07
D7🔒 Locked

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.

Week 2

Production-Grade Single Agent to mini-koda

08
D8🔒 Locked

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.

09
D9🔒 Locked

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.

10
D10🔒 Locked

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.

11
D11🔒 Locked

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.

12
D12🔒 Locked

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.

13
D13🔒 Locked

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.

14
D14🔒 Locked

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.

Week 3

Multi-Agent Collaboration to mini-multi-agent

15
D15🔒 Locked

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.

16
D16🔒 Locked

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.

17
D17🔒 Locked

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.

18
D18🔒 Locked

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.

19
D19🔒 Locked

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.

20
D20🔒 Locked

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.

21
D21🔒 Locked

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.

Week 4

Advanced Topics + Job-Hunt Sprint

22
D22🔒 Locked

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.

23
D23🔒 Locked

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.

24
D24🔒 Locked

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.

25
D25🔒 Locked

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.

26
D26🔒 Locked

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.

27
D27🔒 Locked

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.

28
D28🔒 Locked

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.

29
D29🔒 Locked

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.

30
D30🔒 Locked

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.