Agent Infrastructure

The substrate that lets AI actually write code

Master the Observe-Think-Act-Evaluate loop, tool use and function calling, context management, multi-step reasoning, error recovery, build-fork-integrate decisions, agent memory, multi-agent orchestration, and prompt architecture.

Modules in This Level

4.1 What a Coding Agent Actually Is

Understand the Observe-Think-Act-Evaluate loop that distinguishes coding agents from code generators — and why tool ownership, multi-step state persistence, and self-correction on failure are what make Make's agent fundamentally different from a chatbot that writes code.

4.2 Tool Use and Function Calling

Learn how function calling works at the protocol level — structured JSON from model to platform, validation, execution, and result return — and understand why every tool the agent can invoke is simultaneously a product decision about capability, attack surface, and error surface.

4.3 Context Management and Retrieval

Learn why context engineering outweighs model capability in agent performance, and master four retrieval strategies — file tree indexing, semantic search, dependency graph analysis, and recency heuristics — for navigating a 500K-token codebase within a 200K-token context window.

4.4 Multi-Step Reasoning and Planning

Learn how production coding agents use a plan-execute-verify loop — ordered steps with explicit success criteria, per-step verification, and dynamic replanning when results reveal false assumptions — rather than generating all code simultaneously and hoping it coheres.

4.5 Error Recovery and Graceful Degradation

Master three recovery strategies — retry with fix, rollback and replan, checkpoint-based partial recovery — and learn to detect failure cascade before it propagates, because a silent failure at step 7 typically produces a codebase that is harder to debug than a clean crash.

4.6 Build, Fork, or Integrate?

Evaluate three paths for Make's agent infrastructure — build from scratch for full canvas integration, integrate Claude Code for model improvements, or fork Opencode for community momentum — using a framework that maps differentiation value against build cost and vendor exposure.

4.7 Agentic Workflows in a Design Tool

Understand what a canvas-aware agent requires — design token mapping, component library matching, canvas-to-code tool calls — and why the layer connecting Figma variables to generated code is a Platform PM deliverable, not emergent model behavior.

4.8 Cost, Latency, and Token Economics

Build the per-session cost model for Make's agent — input tokens, cached context, tool results, and generated output — and use that math to understand why the heavy user problem drives pricing strategy and when usage-based billing beats a flat subscription.

4.9 Level 4 Checkpoint

Synthesize Level 4 in a VP-level scenario: given five minutes to recommend whether Figma builds or integrates its agent stack, practice structuring a decision around differentiation value, build cost, vendor risk, and time-to-market — without deferring to engineering.

4.10 Agent Memory & Persistent State

Distinguish agent memory from context — dormant across sessions versus active within one — and learn which four categories are worth persisting across sessions (architecture decisions, preferences, error patterns, codebase structure) versus what to re-derive to avoid stale state.

4.11 Multi-Agent Orchestration & Handoff

Understand why multi-agent specialization creates handoff problems — full history forwarding degrades accuracy 15-20%, minimal summaries trigger 30%+ round-trips — and how structured typed handoffs carry exactly what the receiving agent needs without either failure mode.

4.12 Prompt Architecture as a Discipline

Treat the system prompt as a product artifact with co-ownership across engineering, PM, and policy — structured into versioned sections for identity, tool catalog, coding conventions, safety constraints, and error handling — so behavior changes require deliberate review.