A Better Workflow for AI-Assisted Coding: Lessons from Matt Pocock

I recently watched Matt Pocock's workshop, Full Walkthrough: Workflow for AI Coding.

The main takeaway: Good AI-assisted coding is not about writing better prompts. It's about applying solid software engineering practices to AI agents.

LLMs tend to become less reliable as their context grows.

He uses roughly 100K tokens as a practical warning threshold, not a universal technical limit.

Instead of immediately asking AI to implement a feature, Matt uses a custom "Grill Me" skill.

The AI interviews the developer, asking questions one at a time and recommending possible answers.

For example, when building a gamification feature:

The goal is to reach a shared understanding before implementation.

Planning requires human involvement. Coding can be delegated much more easily.

Once the requirements are clear, create a Product Requirements Document (PRD) covering:

Next, break it into independent issues with explicit dependencies. This creates a Kanban-style backlog that agents can work through, potentially in parallel.

AI often prefers implementing features horizontally:

The problem is that meaningful end-to-end feedback comes too late.

Matt recommends vertical slices (tracer bullets) instead.

For example, implement one small feature that includes:

Each slice delivers something functional and testable.

This makes integration problems visible much earlier.

Once the backlog is ready, implementation can become an automated loop:

Matt demonstrates this with a Ralph-style loop.

For parallel execution, he also introduces Sand Castle, which uses isolated Git worktrees and Docker sandboxes for agents.

Separate agents can handle planning, implementation, review, and merging.

Matt strongly recommends TDD (Test-Driven Development) for AI agents.

Writing tests first makes it harder for AI to generate weak tests that merely confirm its existing implementation.

More importantly, AI needs fast feedback loops:

The quality of your feedback loops often determines the quality of your AI-generated code.

Another important lesson comes from A Philosophy of Software Design.

This is preferable to many tiny, tightly coupled modules.

The developer should understand and control the overall architecture while delegating internal implementation details to AI.

This helps prevent losing architectural understanding as AI generates more code.

Automated tests passing doesn't guarantee a good product.

Matt emphasizes that humans still need to:

He also recommends using a fresh AI context for code review rather than asking an agent to review its own work after a long implementation session.

QA findings can become new backlog issues, creating a continuous improvement cycle.

Idea ↓ Grill Me (Requirements Alignment) ↓ PRD (Define the Destination) ↓ Independent Issues (Vertical Slices) ↓ AI Implementation (Ralph Loop) ↓ TDD + Automated Feedback ↓ AI Code Review ↓ Human QA ↓ New Issues / Improvements ↓ Repeat Enter fullscreen mode Exit fullscreen mode Final Thoughts The biggest lesson from this workshop is that AI doesn't replace software engineering fundamentals. It makes them even more important.

Good architecture, small tasks, clear requirements, automated tests, and continuous feedback are what make AI coding agents effective.

The developer's role increasingly shifts from writing every line of code to defining requirements, designing systems, providing feedback, and maintaining quality.

AI can handle much of the implementation, but humans still need to own the decisions and the final product.

Source: Matt Pocock — Full Walkthrough: Workflow for AI Coding (YouTube)

Suggested DEV.to tags: #ai #programming #productivity #softwareengineering