Building AI Coding Assistant from scratch

Unlock how Agentic coding assistants actually work with “Building Agentic Code Assistant from Scratch” This course is for developers who want to see under the hood of products like Cursor, Claude Code, and Codex—not only how to drive them from the UI, but how the agent loop, tools, and coordination are put together in code.

You will learn to design systems where a central planner delegates to specialised workers, shares knowledge through a persistent store, and verifies outcomes—the same primitives that power long-running, repo-aware assistants, whether they present as a single chat or as multiple roles behind the scenes.

Why this course (and what it maps to)

Today’s AI code assistants feel like magic in the editor: they read your tree, run commands, edit files, and keep context across turns. Underneath, they are still agentic systems: sustained tool use, session memory, context management, planning and repair, and often delegation (explicitly or inside one model with structured steps).

Products such as Cursor, Claude Code, GitHub Copilot / Codex agent modes, Devin, and Deep Research –style tools all lean on the same building blocks—implemented with different UX and infrastructure, but the same conceptual spine. This course teaches those mechanisms from first principles: agent loops, action routing, history, subagent lifecycles, and shared context—so you can read how a real assistant behaves, extend ideas safely, or prototype your own without treating the stack as a black box.

What you will learn

• The agentic core of a coding assistant (hands-on)
  Implement multi-role flows—for example an Orchestrator that plans and delegates, an Explorer with read-only access for investigation and verification, and a Coder with write access—mirroring how production assistants separate read, write, and coordination without hiding the control flow.

• From product behaviour to implementation
  Map what you see in Cursor, Claude Code, and Codex-style agents (plans, diffs, terminal use, file edits, multi-step tasks) to concrete components: prompts, tool schemas, turn state, and when to stop or escalate.

• ReAct-style reasoning and action
  Study the ReAct pattern—interleaving reasoning and tool actions in language models—and implement it inside your agent loop: turns, structured actions, and stopping conditions—the same pattern many coding assistants wrap with product UX.

• Advanced prompt and system-message design
  Craft system prompts and instructions that stabilise behaviour across orchestrator and subagents: delegation, reporting, safety boundaries (e.g. read-only vs write tools), and recovery from failures.

• Shared memory and task tracking
  Build a Context Store for accumulated findings and a Task Store for subtasks and status—so agents compound knowledge instead of repeating work, similar to how assistants must retain “what we already tried” across a long fix.

• Middleware-style agent pipelines
  Compose cross-cutting behaviour—logging, tracing, truncation, error recovery, session history—in a pipeline around turns and tasks, mirroring maintainable patterns behind serious assistant backends.

• Interactive code-alongs
  Follow live coding modules that mirror a real codebase structure: agent core, orchestrator session, handlers for file and shell tools, and end-to-end runs against a repository.

• Capstone project
  Consolidate everything by implementing (or extending) an Agentic coding assistant: user submits a high-level task; the orchestrator investigates via an explorer, stores context, delegates implementation to a coder, and verifies results—demonstrating delegation, verification, and shared state in a single coherent system.

Course benefits

By the end, you will understand both the theory and the implementation path for agentic coding assistants: planning, delegation, tool use, memory, and verification. You will be able to reason about why a product assistant made a given sequence of moves—and what you would change in the architecture—because you will have built the critical pieces yourself.