Skip to main content
AI Proeflokaal

Stop typing code — design the factory that writes it

A hands-on day for developers and tech leads who want to go beyond autocomplete. You learn to work with coding agents such as Claude Code and Codex: from pair programmer, via agents that build features on their own, to a dark factory where agents turn specifications into tested, deployed software — while you design the specs, scenarios and guardrails.

What you'll learn

  1. 01

    Mastering coding agents

    Set up Claude Code, Codex and similar agents: context, CLAUDE.md/AGENTS.md, permissions, hooks, skills and MCP.

  2. 02

    Spec-driven building

    From vague wish to spec, plan and small tasks an agent can execute on its own, test-first.

  3. 03

    Verify instead of read

    Tests, scenarios, review agents and evals as the gate, so you don't have to read every line of code yourself.

  4. 04

    Scaling up to a factory

    Parallel agents, headless in CI, sandboxing, costs and the steps towards a dark factory for your own team.

From pair programmer to dark factory

Thirty typical software development activities, each at three levels: AI helps you as a pair programmer, a coding agent builds while you review, or agents work autonomously while you steer on specifications, scenarios and guardrails. See per phase how far you can move towards a dark factory.

Help
AI as pair programmer
Delegate
Agent builds, you review
Dark factory
Agents autonomous, you steer
Specifying and designing 5 activities
1 Clarify requirements Help Name ambiguities and edge cases Delegate Agent interviews the stakeholder and writes the spec Dark factory Spec as the single source of truth agents build from
2 Choose the architecture Help Think through options and trade-offs Delegate Agent writes ADRs and prototypes per option Dark factory Have several architectures built in parallel and measured
3 Break down work Help Split epics into small, testable steps Delegate Agent produces an implementation plan and issues Dark factory Orchestrator distributes tasks over parallel agents
4 Define acceptance criteria Help Make criteria concrete and measurable Delegate Agent turns criteria into executable scenarios Dark factory Hidden scenario sets the building agent cannot see
5 Capture project context Help Write down conventions and pitfalls Delegate Agent maintains CLAUDE.md or AGENTS.md itself Dark factory Skills and rules that keep the whole factory consistent
Building 5 activities
6 Write new features Help Suggest and explain code Delegate Agent builds the feature in its own branch or worktree Dark factory From spec to merged PR without manual steps
7 Understand existing code Help Explain and search the codebase Delegate Agent documents architecture and data flows Dark factory Living knowledge graph of the codebase for all agents
8 Refactor Help Suggest improvements Delegate Agent executes the refactor behind green tests Dark factory Continuous automated clean-up rounds
9 Modernise legacy Help Explain old code and frameworks Delegate Agent migrates module by module Dark factory Migration as a pipeline comparing old versus new behaviour
10 Build integrations and APIs Help Summarise API documentation Delegate Agent writes client, contract tests and mocks Dark factory Digital twins of external services to test against
Testing and quality 5 activities
11 Write unit tests Help Suggest test cases Delegate Agent works test-first: red first, then green Dark factory Test suite as a contract agents may not modify
12 End-to-end testing Help Write out test scenarios Delegate Agent drives the browser and records evidence Dark factory Scenario validation as the gate instead of human code review
13 Review code Help Explain the diff and flag risks Delegate Review agent reports findings, you decide Dark factory Multiple independent review agents verifying each other
14 Debug bugs Help Form hypotheses about the cause Delegate Agent reproduces, fixes and writes a regression test Dark factory From error report to fix PR without anyone starting it
15 Check security Help Explain vulnerabilities Delegate Agent runs a security review on every change Dark factory Sandboxes, least privilege and audit logs by default
Integrating and releasing 5 activities
16 Maintain the CI/CD pipeline Help Explain failing builds Delegate Agent repairs the pipeline and keeps it green Dark factory Agents as a fixed, headless pipeline step
17 Handle pull requests Help Write PR description and changelog Delegate Agent addresses review comments on its own Dark factory Auto-merge based on scenario score and risk class
18 Update dependencies Help Explain breaking changes Delegate Agent upgrades and fixes breaking code Dark factory Continuously up to date, with supply chain checks
19 Infrastructure as code Help Explain and check configuration Delegate Agent writes Terraform or Bicep, you approve the plan Dark factory Short-lived test environments per agent task
20 Release Help Draft release notes and checklists Delegate Agent prepares the release, you press the button Dark factory Progressive rollout with automatic rollback on metrics
Operating and improving 5 activities
21 Handle incidents Help Summarise logs and traces Delegate Agent investigates the cause and proposes a fix Dark factory Self-healing systems within predefined limits
22 Monitoring and observability Help Design dashboards and alerts Delegate Agent adds instrumentation to new code Dark factory Production signals automatically trigger new tasks
23 Keep documentation current Help Write and rewrite documentation Delegate Agent updates docs with every change Dark factory Docs that never lag because they come from the code
24 Process user feedback Help Cluster and prioritise feedback Delegate Agent turns feedback into issues with specs Dark factory From feedback to experiment to measurement in one loop
25 Pay down technical debt Help Map the debt Delegate Agent pays down debt in small, reviewable PRs Dark factory Fixed budget of agent capacity for maintenance
Setting up the factory 5 activities
26 Choose and configure tools Help Compare Claude Code, Codex and other agents Delegate Set up permissions, hooks and MCP servers per repo Dark factory Shared, version-controlled agent configuration for the whole team
27 Work in parallel with agents Help Make work suitable for splitting Delegate Several agents in their own worktrees at once Dark factory Agent teams with roles: builder, tester, reviewer
28 Measure quality and progress Help Decide what 'good' means Delegate Track evals and scenario scores per change Dark factory Scale autonomy per domain based on measurements
29 Control costs Help Understand token usage and model choice Delegate Set budgets and limits per agent Dark factory Measure cost per delivered feature, not per developer hour
30 Redefine team roles Help Map new skills Delegate Developers steer agents instead of typing code Dark factory People design specs, scenarios and the factory itself

A dark factory is a destination, not a starting point: you earn autonomy with tests, scenarios, sandboxing and measurable quality. You remain responsible for what runs in production. Never give agents production secrets or unrestricted permissions, watch for prompt injection and dependencies, and follow your organisation's security and AI policy.

Programme

A day in detail — no surprises.

# Time Module Content
1 09:00–09:45 The autonomy ladder From autocomplete to dark factory: where is your team, and what is blocking the next step?
2 09:45–10:45 Setting up agents Claude Code and Codex in your own repo: context, permissions, hooks, skills and MCP. Hands-on.
— 10:45–11:00 Break
3 11:00–12:15 Spec-driven and test-first Have an agent build a feature from spec to PR, with tests as the guardrail.
— 12:15–13:00 Lunch
4 13:00–14:15 Parallel and headless Multiple agents in worktrees, review agents, agents in CI and GitHub workflows.
— 14:15–14:30 Break
5 14:30–15:30 Scenarios, evals and trust Hidden scenario sets, quality metrics, sandboxing, secrets and prompt injection.
6 15:30–16:30 Your factory plan Design the first lights-out pipeline for one domain in your own codebase, and a roadmap for your team.

Who it's for

Software developers · Tech leads and architects · DevOps and platform engineers · QA and test engineers · Engineering managers and CTOs

About the trainer

Wiemer Kuik

Trainer & advisor, AI transformation

Over 40 years of business experience focused on integrating business and IT transformation. Specialties: business transformation, change management, IT governance, stakeholder training, transformation management and presentation coaching.

LinkedIn

Book this workshop for your development team, and take the first step from AI assistant to software factory.

Not sure about the fit?

Book an intake — we'll spend 30 minutes on your goals and give you honest advice.

Book an intake