Phone
Address
Wehlistraße 291/1/47
1020 Vienna
DIE WERKSTATT · THE WORKSHOP
I build the workshop. Your team does the work.
Custom software has never been this reachable. What most companies are missing isn't the ability to build. It's the foundation underneath, and someone to teach the tools. Die Werkstatt is one engagement that leaves your team with both.
What this actually is
Four phases over two to three months. I build the technical foundation, build one feature properly as the pattern everything else copies, set up an AI development workflow your people can actually operate, and then hand all of it over.
Your team is in the repository from the first week. By the last phase they're the ones shipping and I'm the one reviewing.
Then I leave. You keep building.
Why This Works Now
AI made writing code cheap. It did not make systems cheap.
Your team can now generate a working feature in an afternoon. What they can't generate is the thing underneath it: the data model that still makes sense after the fiftieth change, the deployment that doesn't break on a Friday, the guardrails that stop an agent from quietly doing the wrong thing at scale.
That first layer is still engineering. It's also the only part you genuinely need an engineer for.
The cost of a feature collapsed
Work that used to justify a three-person team for a quarter is now days. Software that was never worth commissioning suddenly is: the internal tool, the niche portal, the thing only your industry needs.
The cost of a mistake didn't
A weak schema, an unclear boundary, or a missing test still compounds. Agents make the same mistakes faster and more consistently than people do, which makes the foundation matter more than it used to, not less.
Domain knowledge became the bottleneck
The person who understands your business is now closer to being able to build for it than the person who understands frameworks. That's a genuine shift, and it favours you. Somebody just has to set the constraints first.
Demos stopped being the hard part
Most stalled AI projects didn't fail at prototyping. They failed at everything after: authentication, permissions, data migration, deployment, review, and knowing whether the output is correct. That's the gap this closes.
Four Phases
From empty repository to a team that ships without me
Two to three months end to end. Phase 3 can also be booked on its own and applied to a codebase you already have.
1. Foundation
2 to 3 weeks
The decisions that are expensive to reverse: domain and data model, service boundaries, authentication and permissions, environments, CI/CD, deployment, logging and observability. Laravel and Vue.js by default: boring, well-documented, and easy to hire for.
At the end of this phase there is a running application in production. It doesn't do much yet. Everything after this is addition rather than repair.
2. The Golden Path
3 to 4 weeks
One real feature, built end to end, as the reference every later feature copies: the paved road. Form to database to permission check to test to deployed screen.
This is what turns a codebase into a pattern. It's also what agents imitate: give a model a strong reference implementation and its output stops being generic and starts looking like your system.
3. AI Development Workflow
2 to 3 weeks
The part almost nobody sets up properly. Agent instruction files and context engineering so models understand your domain. MCP integrations against your real systems. Sub-agent roles for planning, implementation, and review. Spec-driven loops, so work starts from a written intent rather than a vague prompt.
Then the safety layer: evals that measure whether output is actually correct, guardrails and review gates, and a test suite wired as the agents' feedback loop. Add loop and graph engineering for the multi-step work where a single prompt drifts.
4. Handover & Enablement
ongoing, optional
Pairing sessions with whoever will carry this: developers if you have them, capable non-developers if you don't. Runbooks, architecture notes, and practical training in steering agents: how to brief one, how to review what it returns, when to stop and think instead.
By the end, your team takes its first steps into a larger world and I stop being necessary. Reserved office hours afterwards if you want a second opinion on hand. Not a dependency, just a phone number.
What You Own at the End
A running product. In production, with real users, not a prototype waiting for a rewrite.
A pattern to copy. One feature built properly, the one every later feature is modelled on.
A workflow that holds. Agents working inside guardrails your team understands and can adjust.
The repository and the knowledge. Everything documented, nothing dependent on me staying.
Under the Hood
For the person you forward this page to
Foundation: Laravel, Vue.js, TypeScript throughout, PostgreSQL or MySQL, AWS infrastructure as code, GitHub Actions CI/CD, staging and production parity, structured logging and observability from day one.
Agentic workflow: agent instruction files (CLAUDE.md / AGENTS.md), context engineering and retrieval over your own documentation, MCP servers exposing your real systems to the model, sub-agent orchestration for plan / build / review, spec-driven development, and versioned prompts treated as source code.
Correctness and control: eval harnesses with regression suites, automated guardrails, human-in-the-loop approval gates on anything that writes to production, cost and token observability, and deterministic tests as the agents' feedback signal.
Loop & graph engineering: explicit state machines for multi-step agent work, with defined transitions, retry and escalation paths, and termination conditions, so long-running tasks converge instead of drifting.
Handover: written architecture decisions, runbooks, seeded local environments, and a deployment pipeline your own people can operate.
Who This Is For
Three kinds of client
Established companies without a development team
Manufacturing, logistics, healthcare, professional services. You know your process better than any software vendor ever will, and the standard product doesn't fit it. Until recently your options were an expensive custom build or another spreadsheet. Now there's a third: own the tool, and have your own people extend it.
Founders with a product and no CTO
You understand the market and the customer. You don't need a technical co-founder to hold the keys. You need a foundation that won't collapse under early traction, and the ability to iterate on it yourself while you look for the right team.
Teams already trying to adopt agents
You have developers. What you don't have is a workflow. Output quality swings wildly, nobody trusts the review process, and half the experiments never merged. Phase 3 can be booked on its own, applied to your existing codebase.
What I Bring to the Foundation
Fifteen years of production systems
Including a registration platform handling 300,000+ annual sign-ups across 200+ countries. I know which shortcuts are survivable and which ones aren't.
Products shipped this way
b10cks, RAVN Mail, Kessel, and gh0st were all built by one person using the workflow I'll set up for your team. The method isn't theoretical.
European by default
GDPR-compliant architecture, EU data residency, and clarity about which model providers see what. Decided during the build, not audited afterwards.
No lock-in, structurally
The repository, the pipeline, and the documentation are yours from week one. An engagement that ends cleanly is the point, not a risk to be managed.
Shape & Investment
Typical shape
- Foundation: 2 to 3 weeks
- The Golden Path: 3 to 4 weeks
- AI Development Workflow: 2 to 3 weeks
- Handover & Enablement: ongoing, optional
Most complete engagements run two to three months. Phase 3 alone, applied to an existing codebase, is typically two to three weeks.
How I quote
A written estimate before anything starts, showing its reasoning: what I assumed, where the uncertainty sits, and which parts I'd cut first if the budget is tight. You should be able to argue with the number. Plenty of people in this trade would rather you never asked the odds. I'd rather tell you them.
How it's billed
Fixed price per phase where the scope is clear, time and materials against an agreed cap where it isn't. Changes get re-estimated before the work happens, never after. If a phase comes in cheaper than estimated, so does the invoice.
Figures come after the first call, once I know what you're actually building.
How a Project Starts
1. First Call
Free, 30 minutes. You describe the process or the product. I ask the awkward questions, usually about the edge cases you've stopped noticing. If I'm not the developer you're looking for, you'll hear it here.
2. Written Proposal
Scope, architecture approach, phase timeline, and cost with the assumptions attached. Within a week of the call.
3. Agreement
A plain contract: scope, payment schedule, IP ownership, and how either side steps away. The code and the repository are yours throughout.
4. Build & Hand Over
Your people are in the repository from week one, not presented with it at the end. By the final phase they're the ones shipping, and I'm reviewing.
Bring the problem, not the specification
You don't need to know what to build yet. Most first calls start with a process held together by spreadsheets and goodwill. That's a perfectly good place to begin.