Vienna, Austria
Head of Enterprise, everii Group.
Twenty years in one codebase.
I've spent the last two decades building TEAMBOX, the ERP platform for service providers that's become the PSA market leader in DACH — starting as one of its earliest developers, now running enterprise-level client and product work, CI/CD, and the team behind it. My current focus is agentic engineering: building AI-driven development workflows into a live, twenty-year-old codebase without breaking it.
20+ years, one productPHP & DevOps300+ enterprise clientsAgentic engineering focus
Work Highlights · August 1 – September 7, 2026
The latest work
Updated monthly, straight from the actual work — not a highlight reel.
*Dominated by the continuing test-suite rewrite — hand-authored business logic is a smaller slice of that total.
Featured build
The test-suite rewrite outgrew its own estimate
What started as three phases across roughly two dozen modules kept growing. The branch now touches over two thousand files and runs sixteen thousand tests clean — and it's still an open pull request, not a merged one, because a change that size touching every test file earns a slow review, not a fast one.
- Two extensions that had never run, not once. Both checked
instanceofagainst a class name that didn't exist — which PHP quietly evaluates as false. Fixing the typo immediately surfaced 29 files leaking fixture data into whatever test ran next. - Five attempts at the CI topology, all left in the history. Reverted worker splits, a retreat to sequential, a two-phase compromise — the real blocker turned out to be shared storage forcing suites to serialise, not the worker split itself.
- Ten hidden order-dependencies, only visible under real parallelism. Fixing them held one counter-intuitive pattern throughout: global fixes mostly made things worse, per-test fixes held.
- A coverage trade, written down instead of hidden. One test ate 46% of total runtime by design — proving a fast path against a slow reference. The trim kept the comparison that mattered and documented the trade next to the code.
Mainline still runs the old suite while the branch waits on review — which is the point being made in the writeup: something this size doesn't get to skip review just because its own numbers look good.
Read the full writeup →Featured build
An end-to-end suite joined CI — and immediately found two real bugs
A Playwright end-to-end suite went live in CI this window. The interesting part wasn't adding it — it was that both of its early intermittent failures turned out to be real frontend bugs, not test flakiness.
- A frontend bug wearing a test-flake costume. A popup menu forwarded scroll events straight to a handler that assumed an element target — scroll events target the document, which has no such method. A type cast had kept the compiler quiet about it.
- A CSS class that doesn't exist. A missing icon-font weight caused a one-frame layout shift on first hover — enough, occasionally, to make an automated click land on the wrong element.
- Closed a diagnosis gap along the way. Until now, no e2e failure produced a server-side trace at all, because the stack was torn down with its volumes before logs were captured — which is why the first investigation had to be done the hard way.
Both root-caused and fixed at the source, not papered over with a retry.
Read the full writeup →Housekeeping that found a real bug, and unblocked everyone else's PRs
A required static-analysis check had been failing on every mainline run — and blocking every open PR behind it — because the hosted scanner dropped support for the Java version it was bundled with. Traced and bumped to a supported runtime rather than just silencing the check. Separately, a pass to clean up log noise turned up a real bug along the way: two API models wired to the wrong entity meant a bank-accounts read silently returned empty and writes were silently dropped — found by chasing noise, not by looking for it, and covered with new tests.
Agentic Strategies
How I actually build and work with AI agents
Long-form writeups on the methodology — scoping, review discipline, verification, documentation architecture — for anyone doing this kind of work themselves, not just a list of what got built.
Agentic Strategies
Context, Decisions, and Guardrails: Why Agents (and New Hires) Shouldn't Re-Derive Your Codebase From Scratch
Every fresh AI agent session on a legacy codebase faces the same choice: re-analyze everything from the code alone, or read what's already been decided. One canonical guide, read consistently by three different AI tools, and a strict split between what's being asked for, what's been decided and why, and how a specific piece of work is scoped.
Read the full writeup →Agentic Strategies
Instructions, Style, and Memory: How I Keep Several AI-Assisted Projects Consistent
Running several AI-assisted projects at once creates a specific failure mode: each one drifts its own way, and every session re-explains context the last one already worked out. Persistent per-project instructions, one shared style guide, and a memory system that carries lessons across sessions — the scaffolding that stops it.
Read the full writeup →Agentic Strategies
Implementer, Reviewer, Tester: A Workflow for Shipping Features Fast with Claude Code
Recently shipped a full production feature — new client/project number handling with edge cases nobody had scoped up front — in meaningfully less time than the "cheapest possible version" would have taken, using Claude Code as implementer, reviewer, and tester in separate, deliberately isolated roles.
Read the full writeup →Personal AI Research · Proof of Concept, July 2026
Outside TEAMBOX: independent AI research builds
A way to stress-test what Gemini can actually do on real, messy problems instead of toy demos — built independently of TEAMBOX, in Google AI Studio. Keeping both of these consistent with each other, and with the rest of this site, runs on the practice covered in Agentic Strategies →.
Personal AI Research
OSINT Real-Time Tracker — multilingual conflict monitoring, built solo with Gemini
A maps-based dashboard that monitors global conflict events close to real time. It takes open-source reports — social posts, wire dispatches, radio transcripts — in whatever language they were written, and turns them into structured, geolocated, credibility-scored events a researcher can actually use.
- Multilingual intake, no separate translation step. Paste raw source text in Ukrainian, Arabic, French, Hebrew, or English and Gemini handles extraction directly — entities, location, and language nuance in one pass, not a translate-then-analyze pipeline.
- NLP-based geolocation. Gemini resolves place names and context clues into exact coordinates, with the reasoning behind each resolution shown, not just a pin dropped on a map.
- Sentiment and tension scoring beyond positive/negative. Each report gets a sentiment score, a 1–10 tension score, a dominant emotion, and a read on native-language slang and nuance that keyword-based tools miss entirely.
- A transparent, five-parameter credibility grade. Every event is scored 0–100 across source reputation, cross-referencing, evidence level, contextual plausibility, and freshness — with the reasoning shown, not a black-box trust score.
- An autonomous harvester, not just a manual tool. A background scheduler runs the same search-grounded pipeline once an hour, unattended, aimed at a fixed set of named authoritative sources — ISW for Ukraine frontline reporting, UKMTO for Red Sea maritime alerts, IAEA for nuclear-safety monitoring at Zaporizhzhia, CISA and Mandiant for cyber incidents — rather than an open-ended crawl, with every harvest and its full audit trail persisted to Firestore.
This is a personal research prototype, not a production intelligence product — the live feed uses Gemini search grounding against open sources, with a documented offline fallback dataset for when that harvest fails. Built end-to-end (React, Express, Gemini API, Firestore) in Google AI Studio and deployed to Cloud Run.
View live app → Read the full writeup →Personal AI Research
Crimes of the 1% — a structured, sourced database of financial crime and litigation among the ultra-wealthy
A database that catalogs corporate and executive-level financial crime — fraud, market manipulation, tax evasion, state capture — against the actual enforcement outcome on record: criminal conviction, settlement, deferred prosecution, or litigation still in progress. Built the same way as the OSINT tracker: solo, in Google AI Studio, testing whether an LLM can hold a large, sourced, structured dataset together instead of just summarizing text.
- Sourced by design, not by afterthought. Every case record carries one or more citations classified by document type — DOJ filing, SEC order, court judgment, EPA record, ICIJ archive — instead of a single unlabeled link.
- Beyond a dollar figure. Each entry converts a financial penalty into a systemic-impact score and a "worker-wage-equivalent" figure — how many years of an average worker's pay the penalty represents — and a companion inequality dashboard turns the dataset into charts by sector and crime type.
- Two Gemini-powered lenses on the same data. An AI Fact-Finder modal answers ad-hoc questions against the dataset, and an AI Patterns modal surfaces cross-case trends — which sectors recur, which enforcement types are most common — the same "structured reasoning over messy real data" test as the OSINT build.
- A submission path, not a closed dataset. A case-submission form lets anyone add a new entry directly — published immediately with an "AI-generated, unreviewed" disclosure badge, so the dataset isn't limited to whatever I find on my own research pass.
Early-stage research build — React, TypeScript and Firebase/Firestore, seeded with an initial dataset rather than a continuously fact-checked ledger. Treat individual case entries as a starting point for your own verification, not a settled record.
View live app → Read the full writeup →