From ebe319fb9d525d73db179574ab9c6b0017f7855e Mon Sep 17 00:00:00 2001 From: danallsop Date: Mon, 18 May 2026 16:40:47 +0100 Subject: [PATCH 1/6] Add blog post "Sustainable acceleration and the Agentic Software Development Life Cycle" --- ...c-software-development-life-cycle.markdown | 58 +++++++++++++++++++ 1 file changed, 58 insertions(+) create mode 100644 _posts/2026-05-18-sustainable-acceleration-and-the-agentic-software-development-life-cycle.markdown diff --git a/_posts/2026-05-18-sustainable-acceleration-and-the-agentic-software-development-life-cycle.markdown b/_posts/2026-05-18-sustainable-acceleration-and-the-agentic-software-development-life-cycle.markdown new file mode 100644 index 0000000000..a9aed080be --- /dev/null +++ b/_posts/2026-05-18-sustainable-acceleration-and-the-agentic-software-development-life-cycle.markdown @@ -0,0 +1,58 @@ +--- +title: Sustainable acceleration and the Agentic Software Development Life Cycle +date: 2026-05-18 00:00:00 Z +categories: +- Artificial Intelligence +tags: +- Artificial Intelligence +- AI +- Agentic AI +- ASDLC +- Governance +- Prompt Engineering +- Agile +- People +- Cognitive Entropy +- Delivery +- summary: A discussion of how to successfully leverage agentic AI to raise the productivity ceiling depends on human oversight, governance, and disciplined engineering practices that preserve stability. +author: dallsop +--- + +The traditional Software Development Life Cycle (SDLC) treats requirements, design, implementation, verification, and maintenance as separate phases coordinated by humans. Transitioning to Agentic Software Development Life Cycle (ASDLC) sees AI agents actively participating in reasoning, planning, validation, and optimisation across each of the phases of the SDLC. This presents new challenges to absorb, govern, review, and sustain the pace of change AI enables. In pursuit of raising the ceiling to productivity what do we need to remain mindful of? + +Transitioning to ASDLC is underpinned by organisational processes, governance, and culture. AI amplifies existing engineering culture and so organisations with fragmented processes, inconsistent standards, or weak architectural discipline will discover that AI scales disorder just as efficiently as it scales productivity. Thus organisations must take steps to review and strengthen the foundations of their SDLC to ensure that AI serves to accelerate value delivery. + +Establishing and refining clear policies regarding AI agents is essential. These should cover a range of areas providing guidance to human engineers regarding approved AI use, cost and resource consumption, data protection, and escalation paths. There should be a clear message that reinforces judgement as a fundamentally human responsibility which should not be delegated to AI. + +The role of tech leadership shifts to orchestrating collaboration between humans and AI agents. Responsible use of AI requires fostering a culture of healthy scepticism, and reinforcing a core principle that humans must remain firmly in the driving seat at all times. Targeted training can help reinforce that AI agent output should not be accepted passively. Such training can promote good practices including questioning AI agent assumptions and independently validating AI agent reasoning. + +Human engineers move up the value chain focusing less on implementation and more on orchestrating design, evaluating trade-offs and shaping architecture. Their efforts to simplify are becoming increasingly strategically critical including reducing technical debt, minimising maintenance surface area, and preserving architectural clarity. In addition, prompt engineering is now a core competency, with AI agents' effectiveness depending on how effectively humans can define objectives, constraints, and architectural intent. This skill requires continuous refinement as model updates can greatly alter the output of prompts. Great prompts can (model updates permitting) be shared across teams as reusable interaction patterns between human engineers and AI agents. Planning benefits heavily from well-structured prompts reducing unnecessary iteration and minimising wasted AI Compute Unit (ACU) consumption. Plans very rarely survive implementation unchanged, but spending the time to resolve ambiguity before generating code is significantly less costly than correcting flawed assumptions afterwards. + +The surge in AI generated activity is already exponential, placing significant infrastructure and scaling pressure on platforms such as GitHub. However human attention does not scale exponentially. As AI generated activity such as pull requests continues to increase a psychological strain can emerge in the form of mounting expectations for human engineers to review, comment and merge in increasingly compressed timelines. Let us take a moment to consider the Japanese concept of ma (間) which refers to intentional space or pause in both physical and temporal contexts. Hayao Miyazaki, co-founder of Studio Ghibli, once described it by clapping repeatedly and explaining “The time in between my clapping is ma. If you just have non-stop action with no breathing space at all, it’s just busyness.”. As human engineers begin collaborating with AI agents intentional pacing becomes essential to supporting them as effective stewards of their systems. This is not inefficiency but instead actively preserving long-term coherence in systems adapting to accelerated delivery: + + + For human engineers, this means providing sufficient time to properly evaluate changes before signoff, enabling them to act as a stabilising force. + + + For teams, this means allotting deliberate pauses for reflection, continuous learning and iterative improvement of collaborative AI agent workflows. + + + For codebases, this means protecting system robustness by mitigating the effect of code churn at machine scale. In practice, this may require introducing cooldown periods after high entropy changes, or throttling the volume of AI agent pull requests. + +One emerging anti-pattern of Agentic AI is the overproduction of engineering artifacts (especially markdown files) at a volume and pace that cannot be comfortably consumed by human engineers. Organisations need to maintain their information architectures by actively reducing file fragmentation, removing file duplication, standardising naming, and maintaining reliable knowledge sources. These measures are essential for helping human engineers navigate information, understand systems, and avoid cognitive saturation. Furthermore, there needs to be a focus on making sure generated content is not hostile for humans to engage with. This requires actively reducing cognitive entropy: + + + Providing rendered views instead of raw markdown. + + + Generating diagrams and visual explanations. + + + Adapting information density to meet the needs of the reader. + + + Choose information structures better suited to the context. For example: + + + Logs for a production outage investigation might best take the form of chronological timelines. + + + Meeting discussion notes might best be clustered semantically into conceptual units such as “Decisions Made“, “Action Items”, “Open Questions”, etc. + +Many enterprise systems have been optimised solely for human interaction. As AI adoption increases organisations should consider evolving these systems to better support collaboration with AI agents. Exposing clearer APIs, workflows and AI agent friendly interfaces that enable AI agents to operate more efficiently at scale. Organisations that modernise their platforms in this way will be better positioned than those relying on legacy systems designed for manual workflows and human paced decision making. + +Rapid content generation is creating a profound shift in delivery bottlenecks from implementation to assurance. Implementation time is decreasing making assurance activities before signoff the new dominant constraint. Generating large volumes of code very quickly can leave the review process feeling disproportionate to the implementation effort. It is important not to try and scale old traditional signoff practices which assume human authorship and human scale output. A useful approach is to have AI agents rank the uncertainty of their contributions to flag high entropy changes versus boilerplate ones. Reasoning traces can also be included to provide human reviewers with greater transparency, while also being used as feedback that can be used to refine future prompts. Independent adversarial AI agents can be used to investigate and challenge changes which shifts assurance from a purely manual activity toward a more scalable and collaborative verification process between humans and AI agents. + +### Conclusion +Competitive advantage will belong to organisations that combine AI acceleration with clear accountability, information organisation and accessibility, sustainable delivery pacing, scalable assurance practices, and continuous learning and adaptation. Organisations capable of compounding intelligence, automation, and delivery velocity without compounding instability will define the next era. From 0539b2028c389d27cb15c1638d914eea798ccd4a Mon Sep 17 00:00:00 2001 From: danallsop Date: Mon, 18 May 2026 16:49:52 +0100 Subject: [PATCH 2/6] Fixed summary --- ...ion-and-the-agentic-software-development-life-cycle.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/_posts/2026-05-18-sustainable-acceleration-and-the-agentic-software-development-life-cycle.markdown b/_posts/2026-05-18-sustainable-acceleration-and-the-agentic-software-development-life-cycle.markdown index a9aed080be..10f3f8045a 100644 --- a/_posts/2026-05-18-sustainable-acceleration-and-the-agentic-software-development-life-cycle.markdown +++ b/_posts/2026-05-18-sustainable-acceleration-and-the-agentic-software-development-life-cycle.markdown @@ -14,7 +14,7 @@ tags: - People - Cognitive Entropy - Delivery -- summary: A discussion of how to successfully leverage agentic AI to raise the productivity ceiling depends on human oversight, governance, and disciplined engineering practices that preserve stability. +summary: A discussion of how to successfully leverage agentic AI to raise the productivity ceiling depends on human oversight, governance, and disciplined engineering practices that preserve stability. author: dallsop --- From 42938ea4488718c5ea88ecda0ed34508e70246cc Mon Sep 17 00:00:00 2001 From: danallsop Date: Mon, 18 May 2026 16:57:04 +0100 Subject: [PATCH 3/6] Changed bullet point style --- ...ic-software-development-life-cycle.markdown | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/_posts/2026-05-18-sustainable-acceleration-and-the-agentic-software-development-life-cycle.markdown b/_posts/2026-05-18-sustainable-acceleration-and-the-agentic-software-development-life-cycle.markdown index 10f3f8045a..47bd843580 100644 --- a/_posts/2026-05-18-sustainable-acceleration-and-the-agentic-software-development-life-cycle.markdown +++ b/_posts/2026-05-18-sustainable-acceleration-and-the-agentic-software-development-life-cycle.markdown @@ -30,25 +30,25 @@ Human engineers move up the value chain focusing less on implementation and more The surge in AI generated activity is already exponential, placing significant infrastructure and scaling pressure on platforms such as GitHub. However human attention does not scale exponentially. As AI generated activity such as pull requests continues to increase a psychological strain can emerge in the form of mounting expectations for human engineers to review, comment and merge in increasingly compressed timelines. Let us take a moment to consider the Japanese concept of ma (間) which refers to intentional space or pause in both physical and temporal contexts. Hayao Miyazaki, co-founder of Studio Ghibli, once described it by clapping repeatedly and explaining “The time in between my clapping is ma. If you just have non-stop action with no breathing space at all, it’s just busyness.”. As human engineers begin collaborating with AI agents intentional pacing becomes essential to supporting them as effective stewards of their systems. This is not inefficiency but instead actively preserving long-term coherence in systems adapting to accelerated delivery: - + For human engineers, this means providing sufficient time to properly evaluate changes before signoff, enabling them to act as a stabilising force. +- For human engineers, this means providing sufficient time to properly evaluate changes before signoff, enabling them to act as a stabilising force. - + For teams, this means allotting deliberate pauses for reflection, continuous learning and iterative improvement of collaborative AI agent workflows. +- For teams, this means allotting deliberate pauses for reflection, continuous learning and iterative improvement of collaborative AI agent workflows. - + For codebases, this means protecting system robustness by mitigating the effect of code churn at machine scale. In practice, this may require introducing cooldown periods after high entropy changes, or throttling the volume of AI agent pull requests. +- For codebases, this means protecting system robustness by mitigating the effect of code churn at machine scale. In practice, this may require introducing cooldown periods after high entropy changes, or throttling the volume of AI agent pull requests. One emerging anti-pattern of Agentic AI is the overproduction of engineering artifacts (especially markdown files) at a volume and pace that cannot be comfortably consumed by human engineers. Organisations need to maintain their information architectures by actively reducing file fragmentation, removing file duplication, standardising naming, and maintaining reliable knowledge sources. These measures are essential for helping human engineers navigate information, understand systems, and avoid cognitive saturation. Furthermore, there needs to be a focus on making sure generated content is not hostile for humans to engage with. This requires actively reducing cognitive entropy: - + Providing rendered views instead of raw markdown. +- Providing rendered views instead of raw markdown. - + Generating diagrams and visual explanations. +- Generating diagrams and visual explanations. - + Adapting information density to meet the needs of the reader. +- Adapting information density to meet the needs of the reader. - + Choose information structures better suited to the context. For example: +- Choose information structures better suited to the context. For example: - + Logs for a production outage investigation might best take the form of chronological timelines. + - Logs for a production outage investigation might best take the form of chronological timelines. - + Meeting discussion notes might best be clustered semantically into conceptual units such as “Decisions Made“, “Action Items”, “Open Questions”, etc. + - Meeting discussion notes might best be clustered semantically into conceptual units such as “Decisions Made“, “Action Items”, “Open Questions”, etc. Many enterprise systems have been optimised solely for human interaction. As AI adoption increases organisations should consider evolving these systems to better support collaboration with AI agents. Exposing clearer APIs, workflows and AI agent friendly interfaces that enable AI agents to operate more efficiently at scale. Organisations that modernise their platforms in this way will be better positioned than those relying on legacy systems designed for manual workflows and human paced decision making. From 3a8606e067342ae754c7063fb8926f6433ff9994 Mon Sep 17 00:00:00 2001 From: danallsop Date: Mon, 18 May 2026 17:03:00 +0100 Subject: [PATCH 4/6] Changed bullet points style --- ...nd-the-agentic-software-development-life-cycle.markdown | 7 ------- 1 file changed, 7 deletions(-) diff --git a/_posts/2026-05-18-sustainable-acceleration-and-the-agentic-software-development-life-cycle.markdown b/_posts/2026-05-18-sustainable-acceleration-and-the-agentic-software-development-life-cycle.markdown index 47bd843580..b377967660 100644 --- a/_posts/2026-05-18-sustainable-acceleration-and-the-agentic-software-development-life-cycle.markdown +++ b/_posts/2026-05-18-sustainable-acceleration-and-the-agentic-software-development-life-cycle.markdown @@ -31,23 +31,16 @@ Human engineers move up the value chain focusing less on implementation and more The surge in AI generated activity is already exponential, placing significant infrastructure and scaling pressure on platforms such as GitHub. However human attention does not scale exponentially. As AI generated activity such as pull requests continues to increase a psychological strain can emerge in the form of mounting expectations for human engineers to review, comment and merge in increasingly compressed timelines. Let us take a moment to consider the Japanese concept of ma (間) which refers to intentional space or pause in both physical and temporal contexts. Hayao Miyazaki, co-founder of Studio Ghibli, once described it by clapping repeatedly and explaining “The time in between my clapping is ma. If you just have non-stop action with no breathing space at all, it’s just busyness.”. As human engineers begin collaborating with AI agents intentional pacing becomes essential to supporting them as effective stewards of their systems. This is not inefficiency but instead actively preserving long-term coherence in systems adapting to accelerated delivery: - For human engineers, this means providing sufficient time to properly evaluate changes before signoff, enabling them to act as a stabilising force. - - For teams, this means allotting deliberate pauses for reflection, continuous learning and iterative improvement of collaborative AI agent workflows. - - For codebases, this means protecting system robustness by mitigating the effect of code churn at machine scale. In practice, this may require introducing cooldown periods after high entropy changes, or throttling the volume of AI agent pull requests. One emerging anti-pattern of Agentic AI is the overproduction of engineering artifacts (especially markdown files) at a volume and pace that cannot be comfortably consumed by human engineers. Organisations need to maintain their information architectures by actively reducing file fragmentation, removing file duplication, standardising naming, and maintaining reliable knowledge sources. These measures are essential for helping human engineers navigate information, understand systems, and avoid cognitive saturation. Furthermore, there needs to be a focus on making sure generated content is not hostile for humans to engage with. This requires actively reducing cognitive entropy: - Providing rendered views instead of raw markdown. - - Generating diagrams and visual explanations. - - Adapting information density to meet the needs of the reader. - - Choose information structures better suited to the context. For example: - - Logs for a production outage investigation might best take the form of chronological timelines. - - Meeting discussion notes might best be clustered semantically into conceptual units such as “Decisions Made“, “Action Items”, “Open Questions”, etc. Many enterprise systems have been optimised solely for human interaction. As AI adoption increases organisations should consider evolving these systems to better support collaboration with AI agents. Exposing clearer APIs, workflows and AI agent friendly interfaces that enable AI agents to operate more efficiently at scale. Organisations that modernise their platforms in this way will be better positioned than those relying on legacy systems designed for manual workflows and human paced decision making. From fa8e9325ceb83159d2858d945e0729dbac80b938 Mon Sep 17 00:00:00 2001 From: danallsop Date: Mon, 18 May 2026 17:09:27 +0100 Subject: [PATCH 5/6] Changed bullet point styling --- ...n-and-the-agentic-software-development-life-cycle.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/_posts/2026-05-18-sustainable-acceleration-and-the-agentic-software-development-life-cycle.markdown b/_posts/2026-05-18-sustainable-acceleration-and-the-agentic-software-development-life-cycle.markdown index b377967660..9bd725a1f1 100644 --- a/_posts/2026-05-18-sustainable-acceleration-and-the-agentic-software-development-life-cycle.markdown +++ b/_posts/2026-05-18-sustainable-acceleration-and-the-agentic-software-development-life-cycle.markdown @@ -40,8 +40,8 @@ One emerging anti-pattern of Agentic AI is the overproduction of engineering art - Generating diagrams and visual explanations. - Adapting information density to meet the needs of the reader. - Choose information structures better suited to the context. For example: - - Logs for a production outage investigation might best take the form of chronological timelines. - - Meeting discussion notes might best be clustered semantically into conceptual units such as “Decisions Made“, “Action Items”, “Open Questions”, etc. + - Logs for a production outage investigation might best take the form of chronological timelines. + - Meeting discussion notes might best be clustered semantically into conceptual units such as “Decisions Made“, “Action Items”, “Open Questions”, etc. Many enterprise systems have been optimised solely for human interaction. As AI adoption increases organisations should consider evolving these systems to better support collaboration with AI agents. Exposing clearer APIs, workflows and AI agent friendly interfaces that enable AI agents to operate more efficiently at scale. Organisations that modernise their platforms in this way will be better positioned than those relying on legacy systems designed for manual workflows and human paced decision making. From 25fcdb3d93440d432dbeb89d09f5ce6894a19a61 Mon Sep 17 00:00:00 2001 From: danallsop Date: Mon, 18 May 2026 17:20:17 +0100 Subject: [PATCH 6/6] Changed bullet point delimiters --- ...c-software-development-life-cycle.markdown | 25 ++++++++++++------- 1 file changed, 16 insertions(+), 9 deletions(-) diff --git a/_posts/2026-05-18-sustainable-acceleration-and-the-agentic-software-development-life-cycle.markdown b/_posts/2026-05-18-sustainable-acceleration-and-the-agentic-software-development-life-cycle.markdown index 9bd725a1f1..cc70a18f81 100644 --- a/_posts/2026-05-18-sustainable-acceleration-and-the-agentic-software-development-life-cycle.markdown +++ b/_posts/2026-05-18-sustainable-acceleration-and-the-agentic-software-development-life-cycle.markdown @@ -30,18 +30,25 @@ Human engineers move up the value chain focusing less on implementation and more The surge in AI generated activity is already exponential, placing significant infrastructure and scaling pressure on platforms such as GitHub. However human attention does not scale exponentially. As AI generated activity such as pull requests continues to increase a psychological strain can emerge in the form of mounting expectations for human engineers to review, comment and merge in increasingly compressed timelines. Let us take a moment to consider the Japanese concept of ma (間) which refers to intentional space or pause in both physical and temporal contexts. Hayao Miyazaki, co-founder of Studio Ghibli, once described it by clapping repeatedly and explaining “The time in between my clapping is ma. If you just have non-stop action with no breathing space at all, it’s just busyness.”. As human engineers begin collaborating with AI agents intentional pacing becomes essential to supporting them as effective stewards of their systems. This is not inefficiency but instead actively preserving long-term coherence in systems adapting to accelerated delivery: -- For human engineers, this means providing sufficient time to properly evaluate changes before signoff, enabling them to act as a stabilising force. -- For teams, this means allotting deliberate pauses for reflection, continuous learning and iterative improvement of collaborative AI agent workflows. -- For codebases, this means protecting system robustness by mitigating the effect of code churn at machine scale. In practice, this may require introducing cooldown periods after high entropy changes, or throttling the volume of AI agent pull requests. +* For human engineers, this means providing sufficient time to properly evaluate changes before signoff, enabling them to act as a stabilising force. + +* For teams, this means allotting deliberate pauses for reflection, continuous learning and iterative improvement of collaborative AI agent workflows. + +* For codebases, this means protecting system robustness by mitigating the effect of code churn at machine scale. In practice, this may require introducing cooldown periods after high entropy changes, or throttling the volume of AI agent pull requests. One emerging anti-pattern of Agentic AI is the overproduction of engineering artifacts (especially markdown files) at a volume and pace that cannot be comfortably consumed by human engineers. Organisations need to maintain their information architectures by actively reducing file fragmentation, removing file duplication, standardising naming, and maintaining reliable knowledge sources. These measures are essential for helping human engineers navigate information, understand systems, and avoid cognitive saturation. Furthermore, there needs to be a focus on making sure generated content is not hostile for humans to engage with. This requires actively reducing cognitive entropy: -- Providing rendered views instead of raw markdown. -- Generating diagrams and visual explanations. -- Adapting information density to meet the needs of the reader. -- Choose information structures better suited to the context. For example: - - Logs for a production outage investigation might best take the form of chronological timelines. - - Meeting discussion notes might best be clustered semantically into conceptual units such as “Decisions Made“, “Action Items”, “Open Questions”, etc. +* Providing rendered views instead of raw markdown. + +* Generating diagrams and visual explanations. + +* Adapting information density to meet the needs of the reader. + +* Choose information structures better suited to the context. For example: + + * Logs for a production outage investigation might best take the form of chronological timelines. + + * Meeting discussion notes might best be clustered semantically into conceptual units such as “Decisions Made“, “Action Items”, “Open Questions”, etc. Many enterprise systems have been optimised solely for human interaction. As AI adoption increases organisations should consider evolving these systems to better support collaboration with AI agents. Exposing clearer APIs, workflows and AI agent friendly interfaces that enable AI agents to operate more efficiently at scale. Organisations that modernise their platforms in this way will be better positioned than those relying on legacy systems designed for manual workflows and human paced decision making.