Intent
Start with the actual outcome and the quality bar. The agent needs to know what kind of result would satisfy you.
Concrete example“Make this lesson genuinely teach me, not just summarize links.”
Deep lesson
Agentic Engineering
Turn AI-assisted work into a disciplined engineering practice.
Working definition
You should leave with a workflow for planning, delegating, reviewing, and improving agent work instead of just prompting harder.Agentic engineering is the discipline of turning fuzzy human intent into scoped work packets an agent can execute, verify, and improve. It combines product judgment, software engineering, management, review, and taste.
0% complete
Build your own agentic engineering playbook with standards, review loops, and reusable skills.
How it works
A strong agent run is a learning loop
The best workflow is not “ask once and hope.” It is a repeatable loop: define the work, let the agent operate in a bounded area, demand proof, review the result, and turn lessons into reusable standards.
Mental model
Understand the system before watching more videos.
Quick reading pass
Read these four ideas as the vocabulary for agentic engineering. They are the labels you should use when a video explains a tool, habit, or workflow.
Before pressing play, try to predict where each idea appears in the system. That makes the video active instead of passive.
After each video, rewrite one card in your own words. If you cannot simplify it, the concept is not yours yet.
Spec
A concrete description of desired behavior, constraints, files, and acceptance criteria.
Learning move: pause when this shows up, name it, then write the practical rule it implies.Scope
The smallest unit of work an agent can complete and verify without drifting.
Learning move: pause when this shows up, name it, then write the practical rule it implies.Taste
The non-obvious judgment layer: what good feels like for code, design, writing, and product.
Learning move: pause when this shows up, name it, then write the practical rule it implies.Review
A structured pass for bugs, regressions, missing tests, weak assumptions, and product fit.
Learning move: pause when this shows up, name it, then write the practical rule it implies.Two-video prototype
Study these first. Slowly, actively, and with an artifact at the end.
Video 01
Principled Agentic Engineer
Use this as the discipline-setting video. The goal is to identify the habits that separate serious agent work from casual prompting.
- Definition
- A principled agentic engineer designs the work environment around the agent: context, scope, verification, review, and reusable standards.
- Read
- The key shift is ownership. You are not waiting for the agent to be brilliant. You are designing a system where good output is the default because the task is bounded, examples are available, and weak work is caught quickly.
- Visualize
- Map each recommendation to one part of the loop: task packet, agent run, evidence, review, or standard. That turns advice into an operating system.
- Do
- Write your five personal agentic engineering principles. Make each one observable, such as “Every UI change gets a browser screenshot.”
Video 02
This Coding Tool Kills AI Code Slop
Use this as the quality-control video. The goal is to understand why AI output gets bloated, generic, or fragile.
- Definition
- AI code slop is usually unmanaged output: broad scope, weak constraints, no verification, no style standard, and no review pass.
- Read
- Low-quality output often looks productive because many files changed. The better measure is whether the result is simpler, more coherent, easier to verify, and closer to the user’s actual taste.
- Visualize
- As you watch, create two columns: “slop signal” and “prevention mechanism.” Every complaint should become a rule in your agent workflow.
- Do
- Take one weak agent output and write a repair brief: what to remove, what to tighten, what to test, and what design standard it missed.
Put it into practice
Give this prompt to Codex or Claude Code and make the lesson concrete.
Use this when you want to practice managing an agent like a serious collaborator.
Codex or Claude Code
Turn a vague request into an agentic engineering work packet
Act as my agentic engineering coach and implementation partner. I want to practice converting vague intent into a high-quality agent work packet. Use this vague request: "Make my learning app way better and more interactive." Your job: 1. Ask only the minimum clarifying questions needed. If you can make a reasonable assumption, make it. 2. Rewrite the request as a production-quality task packet. 3. Include: - target outcome - audience - files or surfaces likely involved - non-goals - design quality bar - acceptance criteria - verification steps - risks - what should be shown to the user when done 4. Then implement the smallest useful prototype that proves the task packet works. 5. Verify it with typecheck or browser checks. 6. Finish with a concise report: changed files, what to inspect, what still needs human taste review. The output should feel like disciplined engineering management, not a generic AI brainstorm.
Guided watch sequence
Watch with a job to do.
Principled Agentic Engineer
Frame the discipline.
This Coding Tool Kills AI Code Slop
Study how low-quality output happens.
A Pi Coding Agent That Reviews Like You
Encode review judgment.
Deep read
The ideas you should be able to explain out loud.
01
Agentic engineering is management
You are managing a fast junior collaborator. The leverage comes from clear task packets, fast feedback, strong defaults, and refusing vague completion claims.
Proof checklist0/3 done
02
Taste must be operationalized
If you want excellent output, your standards must become prompts, examples, tests, screenshots, rubrics, and reusable skills. Taste that stays in your head cannot guide an agent.
Proof checklist0/3 done
03
Small loops beat heroic runs
Long autonomous runs feel magical but often hide drift. Strong workflows use small loops: inspect, plan, edit, verify, review, then continue.
Proof checklist0/3 done
Misconceptions
What to stop believing.
Agentic engineering means letting agents do everything.
It means designing work so agents can do bounded pieces well.
Code review is optional if tests pass.
Tests catch behavior. Review catches architecture, readability, maintainability, and product judgment.
Practice studio
Learning only counts when you make something.
Write a task packet
Convert a vague feature idea into a scoped implementation brief.
Brief with files, constraints, acceptance tests, and risks.Make a review skill
Write your own review checklist for AI-generated code or UI.
A reusable SKILL.md-style rubric.Run a quality retro
Take one agent output and identify where the prompt, context, or verification failed.
Three process improvements.Recall check
Can you answer without rewatching?
Source shelf
Use videos as a doorway, then verify with primary sources.
ReadingOpenAI Prompt Engineering Guide
Use this to sharpen instructions, examples, constraints, and tool-use prompts.
platform.openai.com/docs/guides/prompt-engineeringOpen sourceDocsClaude Code overviewRead this to compare Codex-style workspace operation with Claude Code’s agentic coding model.
docs.anthropic.com/en/docs/claude-code/overviewOpen sourceReadingGoogle Engineering Practices: Code ReviewStrong baseline for turning human review taste into reusable agent review criteria.
google.github.io/eng-practices/review/Open sourcePodcastLenny’s Podcast: Head of Claude CodeA practical discussion of what changes when coding agents become central to engineering work.
www.lennysnewsletter.com/p/head-of-claude-code-what-happensOpen sourcePodcastNo Priors podcastGood strategy and builder-level context, including recent conversations around agentic engineering and AI-native products.
podcasts.apple.com/us/podcast/no-priors-artificial-intelligence-technology-startups/id1668002688Open sourcePodcastLatent Space: The AI Engineer PodcastBest recurring feed for AI engineering, agents, evals, codegen, and infrastructure.
www.latent.space/podcastOpen sourceWatch next
Excellent related videos that expand the lesson.
Use these after the first two videos. They broaden the idea without losing the thread: architecture, workflow, tooling, review, and operating discipline.
Reusable judgment
A Coding Agent That Reviews Like You
Expands the “taste must be operationalized” idea: your standards need to become instructions, rubrics, and review loops.
Daily builder workflow
Learn 95% of Codex in 30 minutes
Gives the practical Codex control loop: inspect, plan, edit, verify, and report.
Tooling leverage
7 Tools That Make Codex 10x MORE Powerful
Shows how the surrounding toolchain changes what the agent can actually accomplish.
Workflow routing
7 Tools That Make Codex & Claude Code Actually Useful
Useful for comparing what belongs in Codex, Claude, browser tools, project context, and external automation.