Hey, I’m Lukas, a product engineer in Vienna. Agents write the code now. I own both ends: the why that goes in and the trust that comes out. Ten years of building across the stack taught me what good looks like.
Agents write most of the code now. What’s left is the part that was always hard.
WHAT I BELIEVE
My work sits at both ends of the agent: the intent that goes in, and the trust that comes out.
I co-founded a startup, so I look at every task and ask what it does for the business. That habit matters more now that building is the easy part.
The bottleneck moved.
Building got cheap. What’s expensive now is deciding what to build, and knowing whether what comes back is any good. Speed up only the typing and the queue just moves to review.
When we started shipping with agents, finished work didn’t speed up. It piled up, waiting for review and release.
A ticket is not a work order.
Whoever builds something should understand the problem before the ticket is written. Otherwise an agent builds the wrong thing, fast.
A work order says what to build, who builds it and how long it may take. It never says why. With agents, that missing why is where things go wrong: the agent fills the gap with a guess. So I want to know why we need a feature before I design it.
Context beats model.
What’s right for a business isn’t in any training set. It lives in people’s heads. My job is to get that knowledge to the agent at the moment it needs it.
Agents kept writing code that worked but ignored how we do things. Better models didn’t fix that. Writing our conventions down where the agent reads them did.
The maker can’t be the grader.
Whoever built a change shouldn’t be the one to approve it, and that includes the AI. In the end, a person signs off and owns the result.
I tried AI review bots: dozens of comments per pull request, half of them noise, and soon nobody read any of them. So I built CodeBadger to flag less and prove more.
Deterministic where it hurts.
What must never break belongs in fixed rules and checks, not in a prompt. Agents get room to reason where there’s real ambiguity.
An agent once wrote a perfectly reasonable migration that would have locked a large table for hours, live. Since then, that rule isn’t in a prompt anymore. It’s a hook.
Breadth pays off now.
I’ve built apps, servers, payments, messaging and distributed systems myself. Knowing what good looks like in every layer lets me steer agents across the whole stack and judge what they hand back.
Most of what I see in a day, I’ve built some version of before, so I can tell when agent output only looks right. Waving it through because it compiles is the most common mistake I see with agents. It’s the one I’m best placed to catch.
02 / How I build
How I work with AI.
I don’t just prompt agents. I build the system they work in: the brief, the context, the guardrails and the review. My full-stack background lets me judge what they produce, and I’m responsible for the result.
Brief / Context / Build / Review
When a tool is missing, I build it. The review step below runs on one of mine: CodeBadger walks me through a pull request in reading order.
01 / Brief · Before anything is built
Acceptance criteria are the contract.
I write down the outcome, the constraints and how we’ll know it’s done. The agent builds from that brief, and I review against the same criteria.
Without it, the agent fills the gaps with guesses, and review turns into an argument about what was meant.
IdeaAcceptance criteria
02 / Context · What the agent knows
Rules get loaded, not hoped for.
Guidelines and skills live next to the code. When an agent touches something critical, like a database migration, a hook puts the non-negotiable rules into its context right then. I don’t hope the model knows. I make sure it does.
Without it, the agent writes code that compiles and quietly breaks the team’s rules.
Team knowledgeContext on time
03 / Build · Working with agents
Small pieces, run in parallel.
I break work into pieces an agent can finish and check on its own, and run several in parallel, each in its own workspace. I stay the one who decides what gets merged.
Without it, one agent grinds through a task too big to check, and I review a wall of code instead of pieces.
TaskParallel agents
04 / Review · Earning trust
Review follows risk, not authorship.
How closely I read a change depends on what it touches: auth, data, money, public interfaces. A finding has to point at real code or it doesn’t count. A second model checks the work, and a person makes the call.
Without it, large agent pull requests get waved through, and nobody owns what ships.
Pull requestHuman decision
03 / Built for people I care about
We can build anything now. The question is why.
Some of my favourite projects started with someone close to me needing something.
I’ve rarely met a problem I couldn’t find a way around. These are a few of the ways around.
For my son
He wanted bedtime stories where he’s the hero, with songs to go with them. So I built something that writes them for him.
For my wife
She’s a teacher and wanted a quiz her whole class could play at the same time. So I built one.
For my nephew
He’s into escape games and Minecraft. He got a browser escape game and a mod of his own.
None of these needed a business plan. They needed a reason. I bring the same question to work: why are we building this, and how will we know it worked?
04 / MY BACKGROUND
How I got here.
My interest in tech started with the family PC. I went on to study Business Information Technology at the University of Vienna, where I earned my BSc. I’ve been working in web development since 2015, including legal tech and fintech.
Along the way I’ve built web and mobile apps, servers, payments, messaging and distributed systems. That breadth is what I lean on most when I work with agents.
Agentic engineering
Agent workflows, guardrails, review and delivery systems
Product & domain
Requirements, product engineering, a founder’s view of the business
Setting technical direction across teams. Still hands-on in my own areas.
Full-Stack Developer
signteq
Full-Stack Developer
Dotbite
Building since 2015
Web development, APIs and startup experience.
CO-FOUNDER / 2018
getsby is a part of my life I’m proud of.
I co-founded getsby in 2018. A fellow co-founder and I built the hospitality ordering and payments platform from scratch, before we had AI to help us.
I’m still a co-founder and fix the occasional bug, but it hasn’t been my job since 2022. Building a company taught me to take responsibility for the whole product, including the decisions beyond the code.
What we built and learned
We built the frontend, backend and apps ourselves. Along the way, we learned DevOps, servers, AWS and WebSockets.
The hardest part was keeping a distributed system in sync across lots of different clients. We wrote POS integrations and adapters, integrated payments and built systems the business depended on.
+STACKED IN THE STORM
My CV, played loud.
05 / Off the clock
I turned my CV into a metal song.
I made Stacked In The Storm with Suno. It’s about the work I’ve done and the things that matter to me.
Family comes first: I’m a husband and a dad, and work-life balance isn’t up for negotiation. Off the clock it’s metal and drum & bass, gaming, and whatever new tool or gadget just came out. I try them early and keep the ones that earn their place.
[Verse 1 – Screamed]
Family PC, second-hand and humming
Eight years old and something started running
Didn't know the word for it, just knew the pull
Took the spark to Vienna and I fed it full
Lecture halls to live servers, legal tech to finance
Learned the hard way, learned it twice, took every chance
Ten years in the trenches and the fire never dimmed
Still opening new docs at midnight like a kid
[Pre-Chorus – Screamed]
They said burn or be forgotten
Grind until there's nothing left of you
I said watch me —
I'll go further, and I'll still be here when you're through
[Chorus – Clean Vocals]
Bring me what you're building
I'll meet you at the line
Ten years deep inside the fire
And I still love the climb
So let's make something
Worth the hours that it takes
Let's build it right — let's build it right
[Verse 2 – Screamed]
2018, took the leap without a net
Co-founded the thing, and we shipped it, no regrets
Built the whole spine of it — the API, the load
Scaled it up from nothing in a language made of code
Distributed, integrated, mobile, on the wire
Name the layer, I have stood inside that fire
But the part I'm proudest of was never in the stack
It's the people that I built it with, and every one came back
[Pre-Chorus – Screamed]
Clean code, clean hands
No heroes, no alone
Every line I leave behind
Is something you can own
[Chorus – Clean Vocals]
Bring me what you're building
I'll meet you at the line
Ten years deep inside the fire
And I still love the climb
So let's make something
Worth the hours that it takes
Let's build it right — let's build it right
[Bridge – Clean, half-time, ambient]
Six o'clock, I close the lid
There's a small hand waiting and a story to be read
The best thing I ever made
Doesn't compile
[Bridge – Screamed, building]
So keep your all-night martyrdom
Keep the sleepless, hollow crown
I'll be sharper in the morning
While you're grinding yourself down
Guitar in the evening, controller in my hand
Laughing at my own bad jokes
That's the man who builds your systems
That's the man who keeps his word
[Final Chorus – Clean, layered]
Bring me what you're building
I'll meet you at the line
Ten years deep inside the fire
And I still love the climb
So let's make something
Worth the hours that it takes
Let's build it right — let's build it right
[Outro – Clean, quiet, into full band]
Vienna in the window
Coffee going cold
Tell me what you're dreaming of
And let's go build it now
