Over 10 years we help companies reach their financial and branding goals. Engitech is a values-driven technology agency dedicated.

Gallery

Contacts

411 University St, Seattle, USA

engitech@oceanthemes.net

+1 -800-456-478-23

Article Technology
Kelvin Ross Agentic Engineering for software safety

Agentic engineering is changing software safety. Are we ready? 

Article Technology
Kelvin Ross Agentic Engineering for software safety

Every organisation’s AI journey is different, shaped by its people, priorities and appetite for change. In this article, KJR Founder and Chairman Kelvin Ross shares his personal perspective on the opportunities, challenges and lessons emerging from this rapidly evolving landscape, drawing on his experience working with organisations navigating AI governance and adoption.

Executive Summary

Agentic engineering is changing how software is delivered. AI agents can now contribute to planning, coding, testing, documentation and quality activities, shifting the role of software engineers, testers and assurance professionals. 

For organisations developing or assuring software, five implications stand out: 

  • Software delivery is becoming increasingly automated
  • Governance, context, guardrails and verification matter more than ever
  • Requirements, architecture and assurance become more valuable as implementation becomes easier
  • Independence, repeatable evidence and accountability remain essential, but must be achieved differently
  • Organisations that realise the greatest value from AI will balance automation with effective human oversight

The question is no longer whether AI will participate in software development. The challenge is ensuring organisations can maintain trust, safety and accountability as agents take on more of the work. 

Share of code written by AI graph

The software factory is being rebuilt

Traditional software development relied on a relatively clear separation of responsibilities. Requirements were gathered and refined. Architects designed solutions. Developers implemented them. Testers verified them. Reviewers approved them. Different people performed different functions, creating checks and balances throughout the delivery process. 

Agentic engineering changes that model. Software can now be produced much faster than before. Changes that once took days can often be generated in hours. Documentation, tests and code can all be created simultaneously. 

At first glance, this appears to be a simple productivity gain. In practice, it shifts effort elsewhere. As implementation becomes more automated, organisations spend proportionally more effort ensuring that the right thing is being built. Requirements become more important because ambiguity scales faster. Verification becomes more important because output volume increases. Governance becomes more important because decisions are made more quickly. The challenge moves from producing software to maintaining confidence in it. 

Comparison bar charts showing how AI agents shift software development effort from the build phase to specification, review and testing, with reduced effort spent on building.

From coding assistant to software agent

For years, software teams have used tools that help developers work faster. Code completion, automated testing frameworks and intelligent IDEs all increased productivity while leaving the engineer firmly in control. 

AI agents represent something different. Rather than simply answering questions or generating snippets of code, agents can now perform sequences of work. They can analyse requirements, propose designs, modify code, run tests, review outcomes, update documentation and attempt to correct defects. In many cases, they can do so with minimal intervention. 

This shift changes the role of the engineer. As implementation becomes more automated and less dependent on skilled expensive engineers, the work that remains distinctly human becomes more valuable. Defining intent, resolving ambiguity, managing risk, making trade-offs and verifying outcomes move closer to the centre of software delivery. This change is particularly significant for organisations that operate in regulated, safety-critical or high-consequence environments, where confidence matters as much as speed. 

The real value lies in how agents are governed

Public discussion about AI often focuses on the capabilities of language models. In practice, organisations rarely use models in isolation. Agents operate within a broader environment that includes instructions, tools, permissions, workflows, memory, standards and governance controls. This environment is often referred to as the harness. The harness determines: 

  • What information an agent can access
  • What tools an agent can use
  • What actions require approval
  • What evidence is recorded
  • What changes are permitted
  • What controls apply before software is released

For many organisations, these decisions matter more than which model happens to be running underneath. A powerful model without governance creates risk. A well-governed agent operating within clear boundaries is far more likely to deliver consistent outcomes. Organisations can often change models relatively easily. Effective governance practices, assurance processes and organisational capability are much harder to replicate. 

Context is becoming a critical engineering discipline

One of the most common misconceptions about AI agents is that they understand systems the way experienced engineers do. They do not. Agents only know what they have been told, shown or allowed to access. When context is incomplete or contradictory, agents fill gaps with assumptions. 

This makes context engineering increasingly important.

Context engineering is the practice of providing agents with the information required to perform work accurately and consistently. That context may include: 

  • Architecture decisions
  • Business rules
  • System constraints
  • Acceptance criteria
  • Coding standards
  • Safety requirements
  • Regulatory considerations
  • Organisational policies

Good context improves consistency. Poor context creates uncertainty. The implications extend beyond delivery. The same artefacts that guide agents also create evidence. Requirements, design decisions, safety constraints and governance rules become part of the assurance story. The disciplines that improve agent performance often improve traceability and auditability at the same time. 

Independence is becoming harder to maintain

For decades, independent verification has been a cornerstone of software assurance. The principle is simple. The people verifying a solution should not be the same people who created it. Independence helps prevent shared assumptions from becoming shared mistakes. Agentic engineering introduces new challenges: 

  • What happens when the same agent generates the code and the tests?
  • What happens when development and verification activities share the same context?
  • What happens when a single individual orchestrates the entire delivery pipeline through a collection of agents?

None of these situations automatically create failure. However, they can reduce the effectiveness of independent review. A misunderstanding can easily propagate through requirements, implementation and verification if every stage relies on the same assumptions. For organisations operating in safety-critical environments, independence remains essential.

The objective is not to remove agents from the process. It is to design delivery systems that preserve independent judgement. That might include:

  • Independent human approvals
  • Separate verification activities
  • Alternative testing approaches
  • Independent requirements reviews
  • Distinct governance checkpoints

The biggest risk may be human complacency

Many discussions about AI focus on technical limitations. Yet one of the most significant risks may be human behaviour. As outputs improve, people are naturally inclined to trust them. An AI-generated result often looks polished, coherent and complete. The better the output becomes, the easier it is to assume it is correct. This creates a subtle risk. Reviews become shorter. Questions become less frequent. Assumptions are challenged less often. Over time, confidence can become disconnected from evidence. 

Experienced engineering organisations understand this problem well. Similar patterns have existed in software testing, automation and operational monitoring for years. When systems perform reliably, people naturally pay less attention to them. Agentic engineering increases the importance of active verification. Reviewers need to focus on intent rather than presentation. Teams need to verify outcomes against requirements rather than merely checking whether outputs look plausible. Assurance activities need to test assumptions, not simply validate execution. The goal is not scepticism for its own sake. The goal is ensuring confidence is earned. 

AI slop vs human slop illustration

Accountability cannot be automated away

One of the most important lessons of agentic engineering is that accountability remains a human responsibility. AI agents can generate outputs. They cannot accept accountability for decisions, releases or outcomes. Meaningful accountability requires people to have: 

  • Authority to stop a release
  • Competence to assess outcomes
  • Visibility into what changed and why
  • Sufficient capacity to perform genuine review

Without those conditions, approval risks becoming a procedural step rather than a meaningful control. This challenge becomes more significant as delivery accelerates. If agents enable teams to generate ten times more changes, organisations must consider whether existing review and governance practices can keep pace. More output does not automatically mean more value. In some situations, it may simply create more material that requires oversight. 

The future is unlikely to involve humans reviewing every line of code. Instead, human responsibility will increasingly focus on governing systems, evaluating evidence, assessing risk and making decisions at critical points within the delivery process. 

The future of software assurance in an agentic world

Agentic engineering changes how software is produced, but it does not eliminate the need for assurance. If anything, it raises new questions about accountability, independence, evidence and governance. Many of the principles that underpin quality and safety remain unchanged. Organisations still need clear requirements, effective verification, independent review and accountable decision-makers. What is changing is where those activities occur and how they are performed. 

The organisations that successfully adopt agentic engineering will not be those that automate the most. They will be those that combine automation with strong governance, disciplined engineering practices and appropriate human oversight. As AI agents become part of everyday software delivery, the challenge is not simply building software faster. It is ensuring organisations can continue to trust what they build. 

Frequently Asked Questions (FAQs)

Agentic engineering is a software development approach that uses AI agents to plan, build, test, review and improve software with varying levels of autonomy. Unlike traditional coding assistants, AI agents can execute multi-step workflows and work towards defined objectives within human-defined guardrails and governance controls. 

AI-assisted coding helps developers write code faster through suggestions and code generation. Agentic engineering enables AI agents to perform broader delivery activities, including planning, coding, testing, analysing results, generating documentation and correcting defects. 

An AI agent harness is the framework that surrounds an AI model and governs how it operates. It typically includes instructions, memory, tools, permissions, workflows, monitoring and guardrails. 

Common risks include loss of verification independence, automation bias, inadequate oversight, poor requirements, insufficient governance controls and overreliance on AI-generated outputs. 

Yes. However, the use of AI agents does not remove the need for rigorous verification, traceability, governance, change control and assurance activities. 

Independent verification helps identify defects that may originate from shared assumptions, misunderstandings or specification errors. Without independence, the same mistake can flow through multiple stages of delivery. 

Organisations maintain accountability by ensuring named individuals retain authority, competence, visibility and sufficient capacity to review critical decisions and stop releases when necessary. 

AI agents are changing software delivery roles rather than eliminating them. Skills in requirements engineering, architecture, assurance, testing strategy, governance and systems thinking become increasingly important as implementation becomes easier. 

Is your organisation exploring AI-assisted development or agentic engineering, and wondering how governance, assurance and accountability need to evolve with it?
Connect with KJR to discuss software assurance, AI governance and independent verification for AI-assisted delivery.