AI Skills with Matt Pocock

The podcast discusses the evolving role of AI in software development, emphasizing how traditional engineering principles remain crucial despite advancements in AI. Topics include the importance of strategic thinking, clean code, and well-structured workflows when working with AI agents. Concepts like vertical slices, tracer bullets, and domain-driven design are highlighted as effective practices that help both humans and AI navigate complex systems. The discussion also explores how AI benefits from clear communication, precise terminology, and modular, text-based workflows.

A significant focus is placed on the challenges AI introduces, such as accelerated software entropy, the risk of poor code quality, and the need for robust feedback loops. Tools like Grill Me and Wayfinder are presented as methods to enforce deeper reasoning and structured planning in AI interactions. The conversation extends to workflow optimization through techniques like Ralph loops, intent-based access control, and search-based memory systems, all aimed at improving agent efficiency and safety. Additionally, the value of classic software engineering knowledge - drawn from books like The Pragmatic Programmer and Domain-Driven Design - is reaffirmed as essential for guiding AI-driven development.

• What if you used AI skills to systematize your most valuable workflows?

  • Move: Identify one repeatable, high-leverage task (e.g., API design, bug triage) and convert it into a reusable AI skill using a markdown folder structure. Publish it as a public GitHub repo.
  • Why Now?: AI agents are increasingly used in dev workflows, and shareable skills (like GrillMe) are emerging as a new distribution layer for expertise - early creators gain visibility and influence.
  • Expected Upside: Attract inbound collaboration, feedback, and potential monetization opportunities; establish authority in AI-augmented development.

• What if you shifted from selling knowledge to selling strategic AI workflows?

  • Move: Audit your past content or courses and rebuild one module around strategic decision-making (e.g., agent loop design, spec-to-tickets breakdown) instead of syntax or facts.
  • Why Now?: AI has commoditized knowledge delivery; demand is shifting toward frameworks that help users think, plan, and structure AI-assisted work.
  • Expected Upside: Differentiate your offering in a saturated education market and capture higher-value customers (teams, companies) investing in AI productivity.

• What if you treated your codebase as an AI platform?

  • Move: Refactor one core module to be more text-based, self-documenting, and modular (e.g., use deep modules, clear naming, tracer bullets) so AI agents can navigate and modify it autonomously.
  • Why Now?: AI agents perform better in clean, structured environments; optimizing for AI today improves both automation readiness and onboarding for junior humans.
  • Expected Upside: Reduce manual maintenance effort over time, enable reliable agent delegation, and future-proof your solo projects for scalable collaboration.

• Identify and codify high-leverage workflows (e.g., using "Grill Me" or "Wayfinder") into reusable AI skills with clear input/output formats to automate recurring technical decision-making.
• Build a personal or product-specific domain language using principles from Domain-Driven Design to reduce ambiguity in AI prompts and improve consistency across code and documentation.
• Structure learning and content offerings around strategic, high-level concepts (e.g., agent orchestration, system design) rather than tactical knowledge, which is increasingly commoditized by AI.
• Implement a hybrid work model - maintain a part-time or flexible role while validating a solo venture (e.g., course, tool) - to balance financial stability with entrepreneurial experimentation.
• Design AI agent workflows using "Ralph loops" or vertical slices: break tasks into small, context-limited iterations with explicit state retention and goal tracking to stay within effective token windows and avoid entropy buildup.