10xDevs: What Five Weeks of Agent-Driven Development Actually Taught Me

I recently completed the third edition of 10xDevs, a five-week Polish course by Przemek Smyrdek and Marcin Czarkowski on integrating AI agents into the full software development lifecycle. It wasn’t about “how to prompt ChatGPT” – instead it was about how to plan, build, test, deploy, and maintain real software with an agent doing most of the typing while you stay accountable for the result.

Here’s my honest review.

What the course actually is

The premise is simple: casual AI coding (“vibe coding”) doesn’t survive contact with real projects. What does survive is a disciplined workflow, and the course teaches one end to end:

1. Idea → Product Requirements Document. Before any code, the agent runs a Socratic session that interrogates your idea – who’s the user, what’s the first valuable flow, what’s explicitly out of scope. The output becomes a PRD that acts as a contract for everything downstream.
2. Product Requirements Document → code. Stack selection based on the problem (not trends), project bootstrap, then a roadmap broken into plan → review → implement cycles – with you reviewing the plan before the agent writes anything.
3. Quality gates. Test plans with priorities, unit and E2E tests (Playwright driven by the agent), hooks that make the agent react to errors on its own, and techniques for reviewing AI-generated code quickly without rubber-stamping it.
4. Legacy code. The part I found most valuable – generating a project map of an unfamiliar codebase, analyzing features, refactoring safely behind tests, and using DDD to carve out domains the agent can work on independently.
5. Team scale. Agent SDKs, cost and metrics tracking, AI reviewers in the CI pipeline, and shared skill registries so a team’s agent knowledge doesn’t live in one person’s head.

Certification required shipping a real project: working auth, actual data management, non-trivial business logic, at least one user-perspective test, and a CI/CD pipeline. I completed mine – the requirements were sane enough to force real engineering rather than a demo page.

What I took away

The specific tools will age – that’s the nature of this space, and the course’s very opinionated workflow is a snapshot of how agent tooling works right now. But the habits underneath it transfer to whatever comes next, and those are what I’d actually put on a CV:

• Requirements as contracts. An agent will confidently implement the wrong assumption at scale. Forcing decisions into written artifacts before implementation eliminated a whole class of rework – and it made me realize how often I’d been skipping this with human teams too.
• Short verification loops. The skill isn’t trusting the agent; it’s structuring work so it can be checked cheaply – small increments, tests as gates, review of plans instead of just diffs.
• Context engineering. Deliberately managing what the agent knows – project maps, rules files, thread lifecycle – is the difference between an agent that’s useful on a 500-file legacy codebase and one that hallucinates architecture.
• Reviewing at speed. AI generates code faster than anyone can traditionally review it. Learning to verify effectively, not just read line by line, may be the most durable skill in the whole course.

Who it’s for

Working developers who already write production code and want a system for AI-assisted development rather than a bag of prompting tricks. If you’ve never coded, this isn’t your entry point. If you’re already deep into agentic workflows, you’ll know parts of it – but the legacy-code and team-scale modules will likely still earn their keep.

Verdict

Recommended. The workflow is prescriptive – deliberately so – and I’d advise treating it as scaffolding rather than doctrine: the exact commands and artifacts will evolve, quickly. But the engineering discipline it drills – contracts, verification, context management – is exactly what separates developers who ship with AI from developers who generate code with AI. Five weeks well spent.

But it’s not flawless. I can’t agree with giving an AI agent a full access to git, project management software and some other parts of the ecosystem – even in a tight harness. It makes me really uncomfortable. There’s no way I’d want to be held accountable for such code.

The course was originally written in Polish, and it’s available in English. I went for the Polish version… and it was really, really hard to process. Terrible mixes of Polish and English, made-up words etc. On top of that you could clearly see parts of the text were AI-generated. It was also full of acronyms. Tough read!

Was it worth the original price? Well, no. Definitely not. It’s priced the same way as the top-of-the line knowledge you can get elsewhere, yet you can see significantly less effort put into making the course.