Introduction

AI coding agents are transforming how fast products can be built — and Omniscient is harnessing that momentum to deliver something truly disruptive. Our first brick is a real-time corporate reputation engine, the foundation for a broader decision-intelligence platform. But the same coding-agent velocity that unlocks this innovation also introduces a new operational risk surface that leaders need to manage intentionally.

How do we build quality while moving fast?

  • The first core idea is to amplify the feedback loops that drive back to developers. Why? Because, whatever tool they use (AI or not), developers stay responsible for every single character committed to the source code. This is crucial. It goes back to legal and financial implications: you can't sue an agent. Agents move the pace, not the responsibility. And models are prone to hallucinations and random behavior; agents can be verbose, lose context, and introduce subtle errors that slip through manual review. Without the right controls, speed becomes a liability instead of an advantage.
  • The second core idea is to balance the unpredictable output of agents with deterministic scripts for parts that need to be reliable (deployment, validation, monitoring).

The software factory, as a socio-technical system, becomes a collaboration between humans, agents, scripts and post-deployment feedback.

Let's detail the most important stages.

Code production

We produce code in a hybrid fashion: human-supervised, coding agent augmented.

Local dev machine: developer and AI agents pair-program and commit code to a dev branch that opens a pull request.
On the local dev machine, the developer and AI agents pair-program, committing to a short-lived dev branch that opens a pull request.

Each developer has their own workflow, but we share tips, tools and models. Everybody is constantly trying to figure out a better way to operate.

Here's what works best for us today (might change next week):

  • Claude Code with skills such as superpowers, gtask or agent-skills.
  • Cursor with Opus 4.6 thinking used with plan mode.
  • A simple agents.md in each repo that refers to more detailed files (design-guidelines.md) so that all agents on all dev machines share common practices.

We are using branches and pull requests. What's important is that they are very short-lived branches — typically less than half a day. This is close to trunk-based development, with one incredible exception: you can run tons of automated verifications on build agents in parallel, much faster than on a dev machine, and without killing flow. I know this will raise eyebrows in the trunk-based development community, but running scripts locally and manually before pushing to main simply doesn't scale.

Code review

The role of the human reviewer is changing. The sheer amount of code produced can be daunting. Automated assistance to human reviewers is mandatory.

CI/CD: a pull request fans out to a human reviewer, a reviewer agent and build scripts, all feeding back to the developer.
In CI/CD, every pull request fans out to a human reviewer, a reviewer agent and build scripts — all feeding back to the developer.

We have found the following strategies to be effective:

  • Rely on scripted checks to spot the basics (linting, compilation, unit tests, security checks…). Classic. Even more important than before.
  • The author should run code review skills (such as pr-review-toolkit) on the PR before publishing to humans.
  • Configure a review agent to spot more issues (Cursor Bugbot for example).
  • Use agents to write informative PR messages, including design and sequence diagrams that clarify what was implemented.
  • Provide one-shot manual QA proof. PR authors should attach concrete proofs that changes actually work. For the UI, screenshots and videos of before/after. For infrastructure, link to the pipeline where the branch was successfully deployed to the dev environment and result of the post-deployment tests. For the back-end, any kind of screenshot or proof (log messages, API response…). Developers must act as the QA of the human-AI pair, complementing automated test suites that are expected in the PR — but it's good practice to check things manually once when new work is created, easing the reviewer's job.
  • Focus human review on higher-level concerns: detailed architecture, user experience and product, relation to other parts of the codebase, missing tests.
  • Scan all changes, even if just skimming through them. There is still a chance that LLMs hallucinated or got poisoned, and the human author was sloppy.

These techniques are crucial as the coding bottleneck tends to move to code review.

Deployment & monitoring

We are doing classic continuous deployment.

Cloud environment: deployment scripts ship to infrastructure, then post-deployment tests, health checks, AI-as-judge, logs and usability testing close the feedback loop.
In the cloud environment, deployment scripts ship to infrastructure; post-deployment tests, health checks, AI-as-judge, logs and usability testing then close the feedback loop.
  • All deployments are scripted (including infrastructure, with terraform).
  • We run post-deployment tests on test tenants up to production (synthetic tests).
  • A comprehensive health check suite validates that each piece of software can effectively count on its collaborators.
  • We invest in monitoring to keep an eye on the health of our software, and to be alerted when things go sideways.

Our plan (not implemented yet) is to use AI to verify both model outputs and the agent behavior, with techniques such as AI as judge or AI as jury. These evaluations should run in the CD pipeline in a timely and predictable way. This approach would extend our automated test strategy: deterministic tests would handle the deterministic parts of software, while AI judges would assess the quality of creative and inherently unpredictable AI outputs. Judge models would need to be chosen and tuned for conservative behavior, prioritizing safety over permissiveness. This remains an open area of investigation.

Conclusion

As agents accelerate work, the only way to maintain quality without creating downstream bottlenecks is to implement a rigorous CD pipeline that automates the constant need for validation and deployment.

We are indeed building a feedback machine that mixes humans, agents and scripts.

The global software factory at Omniscient — humans, AI agents and scripts across the local dev machine, CI/CD and the cloud environment, bound by feedback loops.
The global SDLC at Omniscient: humans, AI agents and scripts across the local dev machine, CI/CD and the cloud environment, bound together by feedback loops.

Key tips to make this work:

  • Find the best tools and learn how to use them. This is crucial as tools are getting insanely capable.
  • Use PRs on short-lived branches with a ton of verifications that run automatically, without disrupting the flow of humans.
  • Implement a rigorous continuous delivery pipeline. Fast and predictable deployment of infra and code. Great testing suites. Fix every defect.

We are only scratching the surface and beginning our journey. Stay tuned.

Thanks everyone in the team for being you.