TRK-001In production
Doing More With Less in QA
Companion to: the entry course
The compression problem, leverage gap, Last 20 Bugs, regression drag audit, AI leverage vs theater, the 90-day plan.
- 6 modules
- ~3.5 hours
- 5 worksheets
- 1 capstone plan
Coming soon · Track 01 in production
Self-paced courses for QA leaders.
The same operating model Loop runs in private engagements, packaged as on-demand tracks you can take at your own pace. Track 01 ships first; the rest land in waves through 2026.
Catalog · 4 tracks planned
The four-track curriculum.
Every track is a companion to one of the published books. Take them in sequence or only the ones that match what you're doing this quarter.
TRK-002Drafting
Quality Engineering Operating Model
Companion to: AI-Native Quality Engineering
Layered tests, named owners, leverage metrics, and the 5-bucket maturity framework. Applied to your team.
- 8 modules
- ~5 hours
- Maturity assessment
- Adoption plan
TRK-003Planned
AI-Driven Test-Driven Development
Companion to: AI-Driven TDD
Tests define intent, AI accelerates implementation, engineers own verification. Translated to your stack.
- 7 modules
- ~4 hours
- Reference repo
- Pairing sessions
TRK-004Planned
Bespoke Agentic Pipelines
Companion to: Bespoke Agentic Pipelines
Roles, permissions, observability, project-specific operating rules. For teams running AI-generated code.
- 9 modules
- ~6 hours
- Pipeline starter kit
- Cohort review
While you wait
Three ways to start now.
Live · WS-001
Doing More With Less in QA. Public Course
Take the live cohort version now. Same curriculum, with the working sessions and Q&A.
See the syllabus →BooksThe bookshelf
Four published methodology books. Every course track is a companion to one of them.
Open the bookshelf →ResourcesTemplates and worksheets
The 90-day plan, the QA Leverage Scorecard, the Regression Audit. All free, all from the same operating model.
Browse the hub →Watch · Companion videos
Talks behind the courses
May 26, 2026
Agentic development wasn't working for my large codebase. Then I implemented anchor tags
Agentic development works great until your codebase gets big. As the repo grows, the AI starts missing context. greps gets unreliable. Planning looks detailed but quietly skips important files. Validation becomes harder. And after enough agentic coding, you end up with random orphaned code scattered throughout the codebase. I spent months trying to solve this problem, and the thing that finally made a major difference was adding anchor tags throughout my codebase. In this video, I walk through what anchor tags are, why they help, and how I use them to make large-scale agentic development more reliable. The basic idea: anchor tags are metadata inside the codebase that give AI a deterministic, queryable system for understanding where things live, how features connect, and what needs to be included during planning and validation. Instead of asking AI to “go research the codebase,” we can point it toward a manifest, have it query relevant anchor surfaces, and then use normal grep/search on top of a much better starting point. This has helped me: - Improve planning accuracy in large codebases - Reduce orphaned and leftover legacy code - Validate refactors with more confidence - Link related code across services - Connect test coverage back to product surfaces - Give AI a better map of the repo without pretending it understands everything I also talk through how we pair anchor tags with policy-as-code rules, why the tag system needs to stay boring, and why this only works if the metadata is enforced consistently. This is not a perfect system, and I’m not claiming anchor tags magically solve agentic development. But for large codebases, they’ve been one of the most useful changes I’ve made. If you’re using AI coding agents on a large repo and running into context, planning, or validation issues, this is worth trying. Topics covered: - Why agentic development breaks down in large codebases - What anchor tags are - How anchor tags create deterministic codebase context - Why AI misses things even with large context windows - Using manifests and custom queries for planning - Validating deprecated features and refactors - Reducing orphan code - Pairing anchor tags with policy-as-code - Mapping tests to code surfaces - Practical rules for keeping anchor tags useful If you want the presentation or have questions about implementing this in your own codebase, drop a comment or reach out. Like and subscribe if you want more videos on agentic development, AI coding workflows, QA, automation, and building software with large language models.
Watch on YouTube →
May 4, 2026
Inside a Real Agentic Pipeline (Step-by-Step Breakdown)
Agentic pipelines sound great in clean demos, but what do they actually look like in production? In this video, I break down one of the real AI development pipelines I use almost every day: how it starts from a prompt, creates its own branch and worktree, runs research, builds a plan, gets reviewed by a second agent, writes failing tests, implements until green, runs policy checks, and produces receipts at the end. I also cover what’s worked, what’s been over-engineered, where deterministic checks matter, and why “just run more agents in parallel” is not always the right answer. Sorry for the lower-energy video, I hadn’t eaten all day before recording this one 😅 Links: Newsletter: https://tinyideas.ai/#newsletters QA work at Loop: https://www.workwithloop.com/ LinkedIn: https://www.linkedin.com/in/ben-f-44778426/ X: https://x.com/FellowsBen
Watch on YouTube →
May 1, 2026
Are Agentic Pipelines Actually Worth It?
Are agentic pipelines actually worth the extra time, tokens, and complexity? My honest answer: it depends. Agentic pipelines can improve accuracy, visibility, governance, and control, but they also add real cost. They often take longer to run, use more tokens, introduce more orchestration, and create another layer of abstraction around your development process. So the question is not “do pipelines work?” The better question is: did this pipeline earn its cost? In this video, I walk through the framework I’m using to evaluate whether an agentic pipeline is actually worth running. That includes measuring the pipeline tax, tracking run receipts, comparing quality improvements, and using a ledger system to understand whether a pipeline is making the work better or just making it more complicated. I also share an example of a pipeline that looked good on paper but probably wasn’t worth it in practice. That’s an important part of the lesson: not every task needs a pipeline. Sometimes a single Claude Code or Codex session, guided by a strong engineer, is enough. The goal is to use pipelines surgically. Start simple. Measure what happens. Add complexity only when the pipeline is solving a real problem. And when a pipeline gets too large, use the data to make it smaller. If you’re experimenting with agentic development, this video is about how to think about ROI, accuracy, governance, and cost before building complex AI workflows everywhere.
Watch on YouTube →Common questions
Before you sign up.
- When does Track 01 open?
- Final cut is in production. Beta enrollment opens first to anyone on the notify list. We'll send a date as soon as we have one.
- Will the courses cost the same as the live workshop?
- The on-demand pricing will be lower than the live cohort. Live cohorts include the working sessions and Q&A. Courses are pure curriculum.
- Can my team buy seats together?
- Yes. Team-license pricing is on the roadmap. Email and we'll set up early access for your team.
- Will it be just video?
- Each module ships with the video, the worksheet templates, a printable summary, and a community thread for the cohort.