This series consolidates my learning journey on AI Agents, mostly my own experiences working with Codex in various projects.

AI Agents 101

This section is my foundation map for AI agents. Most of the first drafts were created with Codex, but I still treat them as my own learning notes rather than finished references. The goal is to build a clear path from the basic idea of an agent to the engineering details that make agents useful in practice.

My contribution to this section is:

  • create the first draft of the high-level topics I want to understand
  • define the structure of each topic, starting from a high-level abstraction and then moving into more concrete engineering details
  • review each draft and add references, examples, or resources when I find something relevant later. For example, I recently noticed more discussion around Loop Engineering, so I added it to From Prompt Engineering to Agent Systems Engineering
  1. Why Agents, Why Now
  2. From Prompt Engineering to Agent Systems Engineering
  3. The Core Agent Model
  4. Agent Loop and Runtime Design
  5. Context and Memory
  6. Tools, MCP, Skills, and Plugins
  7. Orchestration Patterns
  8. Data Layer and Enterprise Integration
  9. Safety, Security, and Governance
  10. Evaluation and Observability
  11. Production Agent Architecture
  12. Agentic UX
  13. Coding Agents as a Case Study
  14. Standards and Ecosystem

Deep-Dive Topics

This section is for topics that I personally find more interesting and want to study more deeply with Codex. Compared with AI Agents 101, these posts are less like a broad curriculum and more like focused research notes. I usually spend more time reading papers, checking claims, organizing evidence, and refining the explanation before publishing them here.

Good Practices

This section collects practical skills, workflows, tutorials, and field notes that have improved how I work with AI coding agents. These notes are not meant to be a polished methodology. They are closer to a personal operating manual: small practices I found useful, mistakes I want to avoid repeating, and workflows I want to keep testing in real projects.

AI Coding Workflow from Matt Pocock

Full Walkthrough: Workflow for AI Coding - Matt Pocock is a practical workshop on turning ambiguous product ideas into agent-ready implementation work. My main takeaway is that AI coding works best when we separate the workflow into stages:

  1. clarify the product goal,
  2. write down the requirements,
  3. pressure-test the plan,
  4. let the coding agent implement,
  5. review and verify the result.

The important artifact is prd.md, the product requirements document. Before asking an agent to write code, I should first make the goal explicit: what problem are we solving, who is the user, what behavior should change, what constraints matter, and what counts as done? A good prd.md reduces ambiguity before the agent enters implementation mode. It also gives both human and agent a shared reference point when the work becomes messy.

This is where the grill-me skill fits. I use it before Codex Plan mode, while the task is still soft and under-specified. Its purpose is not to implement anything yet. Its purpose is to force a shared understanding of the target outcome.

Interview me relentlessly about every aspect of this plan until we reach a shared understanding.
Walk down each branch of the design tree, resolving dependencies between decisions one by one.
For each question, provide your recommended answer.
Ask the questions one at a time.
If a question can be answered by exploring the codebase, explore the codebase instead.

This skill is useful because many failures in AI-assisted coding are actually planning failures. The agent may implement quickly, but if the goal is vague, it will confidently optimize for the wrong thing. grill-me slows the process down at the right moment: before code is written, before a plan hardens, and before hidden assumptions become expensive.

The rough workflow I want to practice is:

  1. start with a rough idea,
  2. ask grill-me to interrogate the goal and assumptions,
  3. turn the answers into prd.md,
  4. enter Plan mode and ask Codex to inspect the codebase,
  5. let Codex implement against the agreed plan,
  6. verify with tests, screenshots, or manual review.

In short: do not use the agent as a faster pair of hands too early. First use it as a thinking partner that helps make the task precise. Once the target is clear, autonomy becomes much more useful.