As the volume of code and product we produce increases, it’s becoming a Sisyphean effort to manually review and test everything. It’s fair to say, as an industry, we are experiencing a real-time breakdown in the established software development lifecycle methods of the past 50 years.
Be honest, how much of the code produced by your last Claude, Codex or Cursor session did you actually read and review?
Did you do a few test runs, ask Claude to summarise the key code changes and then go “looks good to me”?
How many PRs is your company needing to review a week? Is code review now your bottleneck?
While the underlying principles of software engineering should and must still remain (SOLID, Clean Code, DRY etc), this volume of product/code means it may not be possible to fully apply “best practices” and remain competitive in the age of agentic software development.
Therefore, rather than focusing on code quality per se, we could instead focus on measurable outputs that point to the evidence of the code’s correctness.
For example:
- Does the video produced by an agentic test match our expected outcomes for that user journey?
- Over a 30-minute app session, did the memory usage remain stable?
- When the feed list scrolls, does the FPS drop substantially and cause jank?
- While fetching a series of photos, did the app’s memory spike significantly?
At Ansight, we call this philosophy Evidence Engineering; a data-centric method to software proofing.
At the core of this idea is a question, and dare I say a mildly controversial one:
Does it truly matter how the code is implemented, as long as the produced evidence supports that the software works as expected?
If all evidence supports that the software works correctly — there are no memory leaks, framerates are stable, user journeys are correct, network and file I/O is correct, and app state is correct — then the implementation is fit for purpose.
How does this apply in practice?
At Ansight, we view evidence coming in three forms:
- Ex vivo — replay: Evidence after the fact; revisit a captured execution and inspect its recorded evidence. Replay does not require deterministic re-execution. A PostHog or Sentry replay, or app logs, would be ex vivo evidence.
- In vitro — external observation: observe a live app through screens, inputs, logs, network activity, telemetry, and OS behaviour. Capturing a screen recording or externally profiling the app is an example of in vitro evidence.
- In vivo — runtime interrogation: question the live app through an in-process bridge to expose its internal state. An MCP tool exposed by the running app to describe its current state (e.g., a 3D scene graph or in-memory object state) is an in vivo evidence example.
Together, these three evidence types must be captured and structured into a clean, agent-native surface. An agent must be able to slice, dice, inspect and query discrete chunks of all data channels to more easily infer, problem solve and arrive at the correct solution.
Therefore, in evidence engineering, all development and test sessions must produce an extremely detailed record to allow an agent (or human) to validate what happened and then meaningfully investigate issues from data.
Some examples:
- Touch locations, screenshots and visual trees: reconstruct the user journey and the UI state throughout it.
- Framerate, CPU pressure, memory usage: identify areas of poor performance, and help correlate them with the behaviour that caused them.
- App logs, navigation transitions: the app’s behaviour.
- Network traffic, database queries/state, file system snapshots: the app’s inputs/outputs.
- App state snapshots: In-app MCP/remote tools that can be dynamically queried to snapshot an exact moment in time. These snapshots must be stored into a replayable timeline.
- Annotations: point-in-time, or visual, annotations made by either a human or another agent that can be used to specify points of interest.
Evidence engineering is an agent-native software development methodology, underpinned by the philosophy that agents are only limited by the data they have access to.
Establishing a strong evidence base to prove through data that code works as expected enables us to confidently take a few steps back from the implementation details, take a breath, and lessen our overall cognitive load.
How Ansight Applies Evidence Engineering
Ansight brings all three lenses together for mobile applications: recorded sessions for replay, live capture for observation, and runtime tools for interrogation.
Our free CLI tool is able to capture all of these data points (and any arbitrary custom app state), and gives agents an extremely rich tool suite to inspect this data.
We support all major mobile frameworks and have been successfully applying this engineering philosophy at Red-Point (our 3D climbing guide for rock climbers) for the past 18 months.
Try out our free CLI and reach out to us if you’re interested in talking more about this philosophy.