From Traditional Development to AI-Driven Development
A series of five hands-on workshops that take your team from chat-bot prompting to real agentic engineering — working with AI as an engineering tool, not a chatbot.
90% of developers are stuck a generation behind
AI development tools have been through three generations. Autocomplete (Copilot) is yesterday. Chat assistants (ChatGPT) are the day before. Today the industry runs on agentic harnesses — Claude Code, Codex, Cursor Agent — agents that read the codebase, write code, run tests, iterate on errors and deliver a finished result. But most developers still ask ChatGPT to 'write me a function' instead of handing an agent a task plus skill-instructions that encode the company's standards. We teach teams to work with AI as an engineering tool.
Autocomplete
Line-by-line suggestions. Helpful, but you still write everything by hand.
Chat assistants
Copy-paste a question, copy-paste an answer. The model never sees your real codebase.
Agentic harnesses
The agent reads your code, plans, writes, runs and iterates — no manual copy-paste. This is where we teach you to work.
of developers don't trust AI (Stack Overflow 2025) — because they work with it the wrong way.
Who it's for
Developers, team leads and tech leads in companies where IT is an internal department — banks, retail, logistics, telecom, industry. Level: middle and above. The language doesn't matter — the principles are the same for Kotlin, Java, Python, TypeScript, Go and PHP.
The tools we work with
Claude Code
AnthropicAgentic terminal harness. Works with the full codebase; supports skills, subagent pipelines and hooks.
Codex
OpenAICloud agent for running tasks in parallel. Sandboxed environment, GitHub integration.
Cursor Agent
CursorIDE-integrated agent that works against your project rules.
Specialized agents
Narrow toolsFocused agents for review, testing, documentation and migration.
Skills — the through-line of every workshop
Skills are formalized instructions for agents. On a real project we created 15 skills encoding the client's architectural patterns — and the agents generated code indistinguishable from the in-house team's.
Format
Run daily as a one-week intensive, or weekly over a month. Each workshop is 30 min of theory plus 2.5–3h of hands-on practice on real tasks. Everyone works at their own workstation, on their own code.
Five workshops
Agentic development: how it works
- Three generations of AI tools: autocomplete → chat → agents, and why the first two are obsolete
- How an agentic harness works: the agent reads, plans, writes, runs and iterates — with no manual copy-paste
- Claude Code vs Codex vs Cursor Agent: architecture, strengths, and when to use which
- Context window, tool use, subagents — how an agent 'thinks' and why it sometimes fails
- Limits: where an agent is reliable, where it needs control, where it's useless
Each participant takes a task from the backlog (a bug or small feature) and solves it in agentic mode with Claude Code or Codex. We dissect how the agent decomposed the task, which files it read, where it slipped, and how many iterations it took.
An understanding of the agentic working model — and the first experience of delegating a whole task to an agent rather than line-by-line.
Skills: codifying your stack
- Why an out-of-the-box agent doesn't know your stack — and how to fix that for good
- What a skill is: a formalized 'this is how we do it' rule the agent applies automatically
- Real example: how we reverse-engineered three reference repos of a fintech company and created 15 skills (wbkr-error-handling, wbkr-verticle-pattern, wbkr-serialization, …)
- Anatomy of a good skill: description, when to apply, code examples, anti-patterns, reference links
- How to validate a skill: golden-vector tests — write the expected result, check the agent generates it correctly
Each participant picks one recurring pattern from their project (endpoint, consumer, migration, test — anything) and formalizes it into a skill, then gives the agent a task that needs it and iterates the skill until generation is stable.
1–2 working skills on your own stack, and an understanding of how to grow a skill pack.
Pipeline: new features and rewriting legacy
- TDD with agents: why it's not optional but the only way to control generation quality
- Rewriting legacy: how the agent analyzes old code (PHP, Java 8, Python 2) and generates new code that preserves the business logic
- Real example: the contract-repaid module — 14 commits in 3 hours (AMQP consumer, 4 verticles, 2 calculators, sealed exceptions, 50+ tests, docs)
- Decomposing complex tasks so the agent doesn't lose context
Each participant takes a 'new endpoint' or 'refactor a module' task and runs the full lifecycle through an agent, timing each stage. Those with legacy code take a real module and rewrite it.
Experience of the full cycle — and a feel for where the agent gives you 10×, where 2×, and where you still need manual control.
Quality: review, subagent pipelines, iterations
- Layered defense: self-review → external review (subagent) → fix commit → closure marker
- How to set up subagent review: a separate agent with a different context reviews the diff and returns findings
- Typical agent mistakes: style drift, hallucinated APIs, over-abstraction, lost edge cases
- Iterating on a staging environment: a real example — 8 iterations rev1→rev8 over 8 days, ~1h average fix time
- When an agent creates more problems than it solves — and what to do about it
Participants run the code from workshop 3 through subagent review, compare the findings with each other's manual review, and practice the loop: finding → fix commit → re-review.
The skill of managing AI-code quality, and a working subagent-review template for your project.
Scaling: from one developer to a team
- Organizing a shared skill pack: structure, versioning, ownership
- Onboarding through a skill pack: new developer + agent + skills = first task on day one
- Formalizing tribal knowledge: turning 'ask Vasya, he knows' into a skill that just works
- Running several agents in parallel: Codex tasks, Claude Code subagent pipelines — scaling without hiring
- Economics: how to compute ROI and make the case to management
Team exercise: a group of 3–4 takes a shared module, splits the tasks, and each works through an agent with the shared skill pack. Integration, shared review, then a debrief on where the pack helped, where rules were missing, and what to add.
A model for teamwork with agents, and a rollout plan for your own team.
What remains after the training
- A skill pack (5–10 skills) built by participants on their own code during the workshops
- A pipeline template (spec → TDD → generation → review → fix) adapted to your stack
- A subagent-review template for quality control
- Recordings of the workshops (if run online)
- 30 days of chat support for questions as you roll it out
Backed by a real project
The program is built on a real engagement: rewriting a fintech company's service (24 modules, PHP → Kotlin) and refactoring it into the client's native style. Full migration: 33 hours instead of 280–400. Refactoring: 3 weeks instead of 3–4 months. Accepted across 8 rounds — with no reservations.
Cost
On request — it depends on group size and format (online / offline / on-site).
Bring AI-driven development to your team
Reach out to discuss format, group size and timing. I usually reply within 24 hours.