Agentic engineering

Agentic engineering: how we build software and AI that holds up in production

AI coding agents do the implementation. Our engineers own the architecture, the standard the code is built to, the review and the result. You get a decision you can defend in two weeks, code you own and can read, and a written record of every decision an auditor or a buyer may ask about.

Our services are available worldwide,
including Germany

A smiling founder working on a laptop at a desk
Book a call
Profiles
OTP Bank
Bawag
Trusted Payments
Jamdoughnut
Mr Lender
LiechtensteinLife
Avatar Fleet
CC Lab
OTP Bank
Bawag
Trusted Payments
Jamdoughnut
Mr Lender
LiechtensteinLife
Avatar Fleet
CC Lab

Products we have shipped for

The standard on this page was written from shipping products like Jamdoughnut (Open Banking, under FCA and PSD2), pinqDR (binding arbitration online) and Cyberexpert (a compliance SaaS with custom-trained AI inside it). The agents now build to it, and our senior architects maintain it.

The definition

What is agentic engineering?

Agentic engineering is software engineering in which AI coding agents write, run and test most of the code, while engineers remain responsible for what gets built and whether it is correct. The engineer sets the architecture, writes the specification, gives the agents the instructions and tools they need, reviews every change with the rigour of a colleague's pull request, and signs off before anything is merged. The agents work in a loop: generate, execute, read the result, fix, repeat. The engineer works on the loop: what it is allowed to do, what it must check, and what "done" means.

The term settled in 2026. Andrej Karpathy coined "vibe coding" in February 2025 for prompting an AI and accepting code you never read. Within a year, Addy Osmani, Martin Fowler and Simon Willison were using "agentic engineering" for the disciplined opposite: AI does the implementation, the human owns the architecture, the quality and the correctness, and the guidance and sensors around the agent ("harness engineering", in Fowler's phrase) are where much of the engineering now happens.

Two things are called agentic engineering, and we do both. One is engineering with agents: how our team builds software. The other is engineering of agents: putting AI agents inside a client's product under rules. This page is mostly about the first. The last section covers the second, because the same discipline applies.

Where it sits

Vibe coding, AI-assisted development, agentic engineering

Most teams now sit somewhere on this line. The column on the right is the only one we ship to production.

Vibe codingAI-assisted developmentAgentic engineering
Who writes the codeThe AI, from conversational promptsThe developer, with AI completing and suggestingAI agents, from a written brief and a Definition of Done
Who reads the codeNobody, by definitionThe developer, as they goThe engineer who directed the agent, in a recorded self-review; an AI reviewer in rounds; a second qualified engineer for anything touching access, data, secrets, money or a contract
What guides the AIThe last promptThe developer's habitsVeryADR, our written engineering standard, plus project instructions and VeryMemory, our record of past decisions and lessons
Tests"It seems to work"Whatever the developer writesTests the agent must pass, run in the loop; a security baseline before merge
Who is accountable in productionNobodyThe developerA named senior team
Good forWeekend prototypes, demos, proving an ideaEveryday feature work by a capable teamBusiness-critical and regulated software, AI inside products, modernization
Not forAnything customers, auditors or investors depend onCode nobody will review laterNothing it cannot be scoped for; it is slower than vibe coding for a throwaway demo, on purpose
How the three ways of building with AI differ, as we practise and audit them

The evidence

The tools make everyone faster. The system decides whether it holds.

Developers have adopted AI tools almost universally and trust them less than they use them. In the 2025 Stack Overflow survey, 84% of developers use or plan to use AI tools, 46% distrust the accuracy of the output, 66% are frustrated by solutions that are "almost right, but not quite", and 45% say debugging AI-generated code takes longer than writing it. Veracode found security vulnerabilities in 45% of AI-generated code.

Speed is not automatic either. METR's randomized trial in 2025 found experienced open-source developers 19% slower with AI tools while believing they were faster; its follow-up with late-2025 tools found a small speedup that the authors call very weak evidence. DORA's 2025 report puts it in one word: AI is an amplifier. It magnifies the strengths and the weaknesses of the engineering system it lands in.

200 tasks

Reviewed by an AI conformity check against their tickets on one product, at least 90% of findings relevant, rework down from three or four rounds to one or two

That is why we treat the system, not the tool, as the product. On one product, an AI conformity check of every commit against its ticket has run for roughly 200 tasks, with at least 90% of its findings relevant, and rework fell from three or four rounds to one or two. The AI-built apps we have audited or hardened so far, some in finance and healthtech, mostly failed at least two of the first four checks on our production-readiness list. The screens were right. The authorisation, the secrets and the data handling were not.

How a change moves

From brief to merge: one change, five steps

This is the loop every change goes through, whether an engineer or an agent did the typing.

  1. Step 1

    Brief

    Done defined. VeryADR consulted.

  2. Step 2

    Build with AI

    Agents build inside a harness.

  3. Step 3

    Verify

    Tests pass. AI review in rounds.

  4. Step 4

    Sign-off

    Human author. Second approver.

  5. Step 5

    Record

    Decisions, deviations, VeryMemory.

One change, five steps, and the memory that carries what each step learned into the next project's standard.
  • 1

    Brief

    The task is written with a Definition of Done: what must work, what must be tested, what must be documented. Before choosing a pattern or a library, the agent consults VeryADR, our architecture decision record, for the area it is about to touch and cites the decisions it relies on.

  • 2

    Build with AI

    Coding agents implement the change inside our own harness, built around VeryADR: project instructions, the skills they may use, the roles they play, the commands they may run. Small tasks go to small models, hard tasks to the strongest; a task that fails twice moves up.

  • 3

    Verify

    The tests the brief demanded run in the loop until they pass. A separate AI reviewer, on a different model from the one that wrote the code, reviews the change in rounds and tags each finding; the author fixes it or records why not, and a change that still draws findings after three rounds is reworked rather than patched. The security baseline is checked before anything is merged.

  • 4

    Sign-off

    Every change has a human author: the engineer who directed the agent completes a recorded self-review and answers for the change as if they had typed it. An agent is never the author of record and an AI review never counts as an approval. Anything that touches authentication or tenant isolation, database migrations, secrets or deployment, an external API contract, or money also needs the approval of a qualified engineer who did not write it. Nothing in those areas merges without a second person.

  • 5

    Record

    The decisions made on the way are written down with their reasons. If the project departed from the standard, the deviation is recorded with why, what it costs and when it is reviewed. Lessons go into VeryMemory, which the next project reads before it starts.

Steps 1 to 3 are where AI makes us faster. Steps 4 and 5 are why the result is ours to stand behind. The same gate applies whether the repository can block a merge or only detect a missed condition afterwards; a missed review is never silent.

Put one initiative through this loop in two weeks.

A Clarity Sprint takes one bounded initiative or process and ends in a decision you can defend, with a working prototype of the hard part where the question needs one, built to VeryADR. Fixed scope, quoted in the first call. Stop after the sprint and keep the findings, the business case and any prototype; nothing obliges you to continue.

Our standard

VeryADR: the decisions we made before AI, that AI now builds to

Shipping products since 2013 in fintech, health, legal and martech taught us how authentication, permissions, data, errors, deployment and audit trails have to be done. We wrote those decisions down as VeryADR, our own architecture decision record. Our engineers and our agents read it through the same interface, and our agent harness is built around it. It holds more than 100 decisions across twelve areas:

  • Architecture and APIs: modular monolith structure, explicit API contracts and versioning, background jobs, realtime updates and resilient integrations

  • Data: PostgreSQL modelling, safe migrations, search, caching, tamper-resistant audit trails, time zones, backups and disaster recovery

  • Identity and access: authentication, server-side authorisation, tenant isolation, sign-in risk checks, rate limiting, secrets and expiring access links

  • Security: OWASP ASVS and MASVS verification, threat modelling, input validation, Content Security Policy, CSRF protection, upload scanning and supply chain controls

  • Privacy and compliance: GDPR data minimisation, consent and Global Privacy Control, a personal-data inventory, sensitive-data handling, age checks and breach response

  • AI features: a model gateway with fallbacks, prompt-injection and SSRF defences, vector search, usage and cost metering, and AI disclosure

  • Observability and operations: OpenTelemetry tracing and metrics, structured logs, error tracking, graceful shutdown and maintenance mode

  • Quality and governance: risk-based and tiered test suites, synthetic test data, recorded code review, inherited-codebase audits, a go-live gate and a production-readiness gauge

  • Delivery and infrastructure: Docker containers, hosting tiers with infrastructure as code, CI/CD with short-lived credentials, promoted release artefacts and deployment tracking

  • Frontend and mobile: rendering strategy, WCAG 2.2 AA accessibility, React Native with Expo, and search and sharing metadata

  • Commerce and business logic: replaceable payment providers, money in integer minor units, gap-free invoice numbers, price snapshots, multiple markets and explicit state machines

  • Content and communication: files and media, structured content, data imports, generated documents, email, notifications and localisation

A few of the decisions it makes before a project starts

  • Authorisation and tenant isolation enforced at every entry point

  • Audit trails that resist tampering, for records like ledgers and approvals

  • Personal data classified, retained and erased to a written workflow

  • Secrets issued, rotated and revoked through one lifecycle

  • Payment and data providers kept replaceable behind an interface

  • Timeouts, retries and circuit breakers on every outbound call

  • Backups with tested restores, and database changes rolled out without downtime

  • Code written with AI reviewed against a security baseline before it is merged

  • Every web app and service verified against OWASP ASVS Level 2, by someone other than the person who built it

  • OpenTelemetry traces and metrics, plus structured logs with correlation IDs, in every service and job

VeryADR is guidance, not dogma. A project may deviate when it needs to, and must say why, in a record with a named owner, an approval and a review date. That rule is what keeps the standard honest and the record useful.

The human gate

What only an engineer decides

An engineer decides

  • The architecture and the boundaries between systems
  • What the Definition of Done is
  • Whether a change is merged, as its author of record
  • When to deviate from the standard

A second qualified engineer approves

  • Authentication or tenant isolation
  • Migrations
  • Secrets or deployment
  • An external API contract
  • Money

Agents do

  • Draft and implement to the brief
  • Write and run tests
  • Refactor within the boundaries they were given
  • Document what they changed
  • Review a change against its ticket
  • Search the standard and the memory before choosing a pattern

Agents never treat silence as approval. When a brief is unclear, the agent stops and asks, requests approval, or skips and reports. It does not guess.

VeryMemory

Lessons that leave one product and reach the next

Every project writes down two kinds of things: the decisions it took, with reasons, and the lessons it learned, with evidence. Both go into VeryMemory, our cross-project memory, which the next project reads before it starts, through the same interface the agents use to read VeryADR. Memories are evidence, not instructions: they tell the next team what happened and why, and the standard decides what to do about it. Nothing confidential, no credentials, no client data goes in; the lesson does.

One example, anonymised

The standard says database changes are rolled out without downtime: every migration runs in steps that keep the old and the new shape readable at once. On a modernization project the team inherited a table with years of records and a schema that could not be changed in steps without doubling storage for weeks. The team recorded a deviation: one migration in a scheduled maintenance window at night, with the reason (the legacy schema), the cost (two hours of planned downtime, agreed with the client), the safeguard (a tested restore point taken before the window), and a note that the standard holds for every later change. The record sits next to the standard, so the next team that inherits a similar schema finds the reasoning, not just the rule.

AI in your product

The same rules for the agents we ship to you

When the product itself contains AI, a model that classifies, extracts, recommends or acts, we settle the same four questions for every component, per project, and write the answers down:

Which model, and how it is swapped

It sits behind an interface, so a better or cheaper model, or one your regulator prefers, replaces it without a rebuild.

What happens when it is unavailable or unsure

The system does the safe thing, asks a person, or stops and reports. It never treats silence as approval.

Where your data lives

In your cloud or one your regulator accepts, with retention and erasure to a written workflow.

Which decisions are logged, and where

Every decision the model takes, with the inputs it saw and the version it ran, where an auditor can read it.

This is what the Clarity Sprint prototypes and the delivery stage ships. See how an engagement runs

Outcomes

What you get from it

A decision you can defend in two weeks

With a working prototype where the question needs one, because the agents build to a standard that already made the hard decisions, and the engineers spend their time on the parts the standard does not cover.

Predictable delivery

Because the loop is the same for every change and the review gate does not move when the deadline does.

Work that was uneconomic before

Because a change that was shelved as too expensive or too risky is re-estimated with agents doing the implementation and the standard carrying the risk.

Code you own and can read

Written to a standard a new team can pick up, with the decisions and their reasons next to it.

An audit trail of decisions

Not just of code: when a regulator, a buyer or your own board asks why the system does what it does, the answer is written down.

Straight answers

Questions engineers and buyers ask us

Next step

Where to start

Every path starts with a fixed-scope piece of work you can stop after. You keep what it produced.

An initiative to prove

Clarity Sprint, two weeks, ends in a decision you can defend

A prototype that must become a product

Fixed-price audit of an AI-built app

The whole engagement

Sprint, delivery, team

Let's talk

Tell us what you're building.

If it has AI in it and it has to hold up in production, we should talk.

Start a Conversation with Máté and Ferenc

Our usual reply time is 48 hours.

What happens next?

We'll get back to you within 48 hours to schedule a free online consultation with our founders, Máté and Ferenc. They'll discuss your initiative and give you honest, expert feedback on what it will take to build - whether you work with us or not.

Your data is safe

We'll only use what you share here to prepare for the conversation. No lists, no spam, no passing your details to anyone else.

What time zone are you in?

We're based in Budapest (GMT+2), working daily with teams across the EU, UK, US, and UAE. Overlap has never been the hard part.

Would you rather write an email?

Write to hello@verycreatives.com - we reply by the next working day at the latest.

Reachbird

"VeryCreatives is not only a reliable partner for IT-development, but also understands our whole business model completely. Therefore, the VC-team helped us actively to define the right product strategy. Thank you, VeryCreatives!"

Philipp Martin

Philipp Martin

CEO & Co-Founder, Reachbird