<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by swardley on Medium]]></title>
        <description><![CDATA[Stories by swardley on Medium]]></description>
        <link>https://medium.com/@swardley?source=rss-280dd9543ba9------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*89Rf92mwxvAmpoDM.jpg</url>
            <title>Stories by swardley on Medium</title>
            <link>https://medium.com/@swardley?source=rss-280dd9543ba9------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 08:02:52 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@swardley/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com" rel="hub"/>
        <item>
            <title><![CDATA[From here to there and back again.]]></title>
            <link>https://swardley.medium.com/from-here-to-there-and-back-again-a9c24ae69cf5?source=rss-280dd9543ba9------2</link>
            <guid isPermaLink="false">https://medium.com/p/a9c24ae69cf5</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[sovereignty]]></category>
            <category><![CDATA[wardley-maps]]></category>
            <dc:creator><![CDATA[swardley]]></dc:creator>
            <pubDate>Fri, 23 Oct 2026 11:49:27 GMT</pubDate>
            <atom:updated>2026-10-23T11:51:54.350Z</atom:updated>
            <cc:license>http://creativecommons.org/publicdomain/zero/1.0/</cc:license>
            <content:encoded><![CDATA[<p>Competition (from the Latin com, together, and petere, to seek) is the act of groups of people seeking something alongside others. It takes three main forms. There is conflict (fighting others), collaboration (labouring with others towards a shared goal) and co-operation (helping others towards theirs). In most competitive environments we do a bit of all three and combinations thereof. We might co-operate with one group in order to conflict with another, or collaborate with one group in order to co-operate with others. This competition happens over a landscape.</p><p>It’s why when we look at a map of a geographical landscape, we see borders which describe our nations (our national collectives with shared values and behaviours). That border is a boundary. Cross it without our nation’s permission and we enter conflict. Beyond that border, we might co-operate and collaborate with other nations. WW2 was an example of many nations co-operating and collaborating with each other in order to conflict with powers that had expanded across the borders of others. However, we don’t just compete on a territorial (or environmental) landscape. We also compete over political, social, economic, technological and even legal landscapes. All these landscapes can be mapped but we rarely do so.</p><p>We need to clarify some terms here because many businesses have lots of maps, from business process maps to mind maps. The problem with these maps is they share one thing in common. They’re not maps, they’re graphs. A graph is a node and spoke diagram where moving a piece whilst maintaining the relationships doesn’t change its meaning. In a map, the space between the pieces has meaning, it’s the landscape. Move a piece and the meaning changes. Of course, a bit of visualisation helps here.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*594aZLDbNrgeSTNe3U0r2g.png" /><figcaption>In a map, space has meaning</figcaption></figure><p>At various conferences over the last three years, I have gone through the basics of how to map these landscapes with a specific focus on AI and Sovereignty (my “From here to there and back again” series). I start by covering the technique that I developed over 20 years ago, which has been used everywhere from Government Agencies to the giants of Silicon Valley and even in the “out of this” world of Space. However, what has always fascinated me are not the maps per se but the patterns that emerge once you can see the landscape. There are three basic types of pattern. Climatic patterns (the rules of the game), doctrine (principles of organisation) and gameplay (context specific stratagems).</p><p>I could go through examples such as how I used mapping in 2008 to understand the changes of cloud and helped take Ubuntu from 3% of the market to 70% of the cloud market for $0.5M against well funded, well resourced competitors such as Microsoft and Red Hat. But these examples are no different from how Leonidas used the narrow pass at Thermopylae, or Themistocles the straits at Salamis, to turn terrain into a force multiplier. There are over 250 different patterns to use against competitors who are mostly oblivious to the landscape (having no way of visualising it). However, this is an article not a book, so I’ll simply point to examples such as the AWS book <a href="https://www.amazon.co.uk/Reaching-Cloud-Velocity-Leaders-Success/dp/B086PTDP51">“Reaching Cloud Velocity”</a> which discusses mapping, and encourage the reader to explore the wider world of <a href="https://www.swardleymaps.com/">Wardley maps</a>.</p><p>Instead, I’ll focus on the issue of AI, which happens to be a good example of one of those climatic patterns in action.</p><p>What is happening is the industrialisation of machine learning. This is the same pattern of evolution that has happened to many technologies beforehand (cloud being the obvious example) and it creates a set of known effects. Efficiency, accelerated speed through co-evolved practices, access to the adjacent possible, inertia due to pre-existing capital (including practice), punctuated equilibrium, not a question of “if” but “when” … it’s a long list. The interesting part is how this industrialisation is combining with other changes of practice (notably the no-code concept from the world of serverless) to create conversational programming. This combination is known as convergence, and the WEF has some excellent reports on the matter covering everything from quantum computing to robotics (they also uses <a href="https://initiatives.weforum.org/technology-convergence-initiative/home">elements of my mapping</a> in their work).</p><p>I first discussed conversational programming in 2016, and a good friend of mine then built an AI that you had a discussion with and it built other systems. This was presented at AWS re:Invent in 2018 in a workshop called “Alexa, Ask Jarvis to Create a Serverless App for Me”. Today, in the world of GPTs/LLMs, we call this vibe coding. The principle behind it is simple and is derived from the work of Yona Friedman. The process of design can be viewed as a conversation between multiple designers. The question to ask was “What happens when one of the designers is the machine itself?”</p><p>However, this change comes with those known effects. The practices are co-evolving. We don’t yet know how to do this safely or how to maintain human understanding, and it will be many years before those practices have evolved. There is no choice over adopting it (an effect known as the Red Queen) but we will have inertia to it. Again, there are too many effects to list in a short article though we did go through them at the event.</p><p>One thing I will emphasise however is that the act of building something is also the act of making many micro-decisions. In the world of software engineering we do talk about specifications and architectural maps (though they are normally graphs) but the actual architecture is represented by the code and rarely matches the diagrams we draw. This difference has been crystal clear for me during the writing of my book <a href="https://rewilding.dev/">“Rewilding Software Engineering” </a>with Tudor Girba. When an LLM is building your system, it is making all those micro-decisions for you.</p><p>Why does that matter?</p><p>Well, when a human makes those decisions, the choices will often reflect the values of that person (and hence of the collectives they belong to). What gets logged about a user, how long data is kept, what counts as a valid name or address, who the system assumes it is serving. An LLM will make the same decisions based upon its training data and how it was trained. Those values may well represent another culture and not your own. Of course, engineers have long imported values through the frameworks and libraries they use, but they at least chose to import them. With an LLM, the decisions are made for you, at speed and at scale, and mostly out of sight. As Norman Foster once said, architecture is the expression of our values. Since code is the architecture and that code is made of those micro-decisions, it leaves us with a question. Whose values are being expressed, and where are the humans in the decision making process?</p><p>It also explains why these issues are matters of sovereignty. Hollywood shapes what we watch. LLMs shape what we build and how we decide. That makes them a form of non-kinetic power more potent than Hollywood itself. I explored this in a bit more detail in <a href="https://www.swardleymaps.com/posts/2024-02-26-ai-and-the-new-theocracies">“AI and the new theocracies”</a>. Every nation needs to decide where its borders are in the social, economic, technological and political spaces, or whether it is happy just importing the values of other nations into its own decision making. Sovereignty is not just a question of where the data centres are located but instead the training of the models.</p><p>Of course, it’s hard to find those borders and manage <a href="https://www.swardleymaps.com/posts/2025-04-14-sovereignty-and-landscape">the issue of sovereignty</a> if you don’t have a map.</p><p>I’ll be giving a <a href="https://www.mapcamp.co.uk/speak">workshop in London covering these themes on the 12th November</a>. Just less than three weeks from now. I’m quite excited to spend the day mapping.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a9c24ae69cf5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Map Camp]]></title>
            <link>https://swardley.medium.com/map-camp-1f6a21da3f81?source=rss-280dd9543ba9------2</link>
            <guid isPermaLink="false">https://medium.com/p/1f6a21da3f81</guid>
            <dc:creator><![CDATA[swardley]]></dc:creator>
            <pubDate>Wed, 10 Jun 2026 14:26:25 GMT</pubDate>
            <atom:updated>2026-06-10T14:59:22.988Z</atom:updated>
            <content:encoded><![CDATA[<p>… and so it starts.</p><p>We’ve started planning for Map Camp. We’re going to be in Dover at the Masion Dieu on the 18th November 2027.</p><p>In the meantime, we’re going to be running a number of workshops. The first will be on the 12th November 2026 at <strong>THE PALM ROOM, </strong>6–14 Underwood Street, London.</p><p>We’re going to be covering a general introduction into mapping technological and economic spaces including basic patterns. Then we’re going to examine some fun scenarios before lookin at the question of AI and the future of work. After which I’ll be running a general ask me anything session.</p><p>Details and tickets can be found here — <a href="https://www.tickettailor.com/events/swardleymapsltd/2240281">https://www.tickettailor.com/events/swardleymapsltd/2240281</a></p><p><a href="https://www.mapcamp.co.uk/">https://www.mapcamp.co.uk/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1f6a21da3f81" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Brave New World]]></title>
            <link>https://medium.com/mapculture/brave-new-world-53e815e2afe7?source=rss-280dd9543ba9------2</link>
            <guid isPermaLink="false">https://medium.com/p/53e815e2afe7</guid>
            <dc:creator><![CDATA[swardley]]></dc:creator>
            <pubDate>Thu, 12 Mar 2026 02:50:33 GMT</pubDate>
            <atom:updated>2026-03-12T02:51:30.862Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<h4>On Government, Markets and Values.</h4><p>Democratic governments need a society and an economy to govern along with citizens to vote for them. In market societies that economy is a market which itself needs trades which requires property and hence values of exclusion i.e. the belief that there is such a thing as your property and my property. That exclusion can either be through social norms or codified in property law, both of which need some form of force (either social, economic, technological or physical) to enforce it.</p><p>People (i.e. citizens) need markets to buy goods from. That market doesn’t have to be a physical place, it could be distributed. That buying and selling could involve many forms, from some sort of token exchange (e.g. currency) to barter to even some form of social exchange. People also need fairness and opportunity which requires inclusion. Hence, you have two competing values — inclusion and exclusion.</p><p>These values are part of what makes the society. There are many values a society has, not all are uniform, many are evolving. To help with this discussion, I’ve provided a quick map of the above components showing how evolved those area i.e. we have a pretty accepted view of trade but fairness/opportunity is still more converging.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nX8V_jNlHJUZv0ZcxKg4iA.png" /><figcaption>A basic map of society, markets and governments.</figcaption></figure><p>One of the roles of Government (it has many) is to balance these competing needs such as inclusion and exclusion. Get the balance wrong and the people might not vote for you unless you can change the norms in society (think the Overton window). Alternatively, you could undermine the market itself by undermining exclusion or enforcing inclusion. Get it badly wrong and you destabilise society, possibly requiring a different form of Government and/or civil war.</p><p>How you strike that balance and how your democracy operates varies over time and place — there is no single playbook and it is highly contextual. China (a democratic system, just a very different one from how the US operates which itself is very different from how Ancient Athens operated) chooses to prioritise society over the market i.e. the market is seen as a tool of society. In the US, for now, the society is seen as a tool of the market.</p><p>You might not agree but our perceptions are baked into our educational systems and the stories we tell. I’m not going to get into that debate other than to note that even within Western economies, how we consider the writings of the same dead economists varies across societies. US perceptions of what some economist said or what a democracy is are not necessarily the same as Europe or China.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ydueUyUHgu9lTELg5sg9eg.jpeg" /><figcaption>Variation in perception of different economists across societies.</figcaption></figure><p>The interconnections between these components are essential for discussions on sovereignty and where you should invest for societal or market benefit.</p><p>Take healthcare. For societal benefit you’d probably invest in measurement of patient reported outcomes (PROMs) and sharing of medical data. Unfortunately, we don’t have healthcare systems, we have sickcare systems that are governed by clinician reported outcomes (ClinROs) i.e. we are very good at treating symptoms but not necessarily so good at making you healthy. In terms of market benefit, the focus is on personalised medicine and preventative healthcare (in a system which doesn’t effectively measure health outcomes).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TVj17wjALQzN2mnzbkls2Q.png" /><figcaption>Mapping out healthcare, and determining investment areas, 2023</figcaption></figure><p>The same disparity occurs across every industry I’ve examined bar one from education to agriculture. That one was bizarrely Space. Any I digress.</p><p>There is a lazy assumption that market growth equals societal benefit and it is rarely challenged. What appears even rarer is the questioning of how LLM/GPTs can change the values within a society by becoming a new ground truth (see AI and the new theocracies).</p><p>So what triggered this somewhat wandering rant? I just read about “Burger King Adding AI to Employees’ Headsets to Constantly Monitor Whether They’re Being Friendly Enough” and was immediately struck by how much of a forceful corporate invasion of the person this was. This seemed on par with the “Chinese headbands” for primary school children that were trialled and then rejected in China back in 2019 due to public backlash. Chinese officials intervened and ordered the school to suspend the use of the devices. I wonder whether US officials will be intervening and ordering Burger King to stop its own interventions?</p><p>The BrainCo device in China, was of course, built and promoted by a US company known as BrainCo (a competitor to Neuralink) which seems to sell it as a more training and wellness device these days. I suspect it will be soon heading towards those poor Burger King Employees (unless Elon gets to drill holes in their heads first) to ensure that they are not only “being friendly” but are actually “happy”. The soma pills will follow shortly after.</p><p>Which leads me to the point of this discussion. The US Government appears heavily slanted towards the market (and away from society) despite the rhetoric. The LLM/GPTs spreading are not neutral but have embedded values.</p><p>So, how many years will it be before Burger King employees being monitored by AI both in terms of headsets and brain bands is an acceptable norm, given that our norms are being influenced by these AIs?</p><p>10 years? 5 years? Or sooner?</p><h3>Background</h3><p>The post that triggered this: Burger King Adding AI to Employees’ Headsets to Constantly Monitor Whether They’re Being Friendly Enough<br><a href="https://futurism.com/artificial-intelligence/burger-king-adding-ai-employees-headsets">https://futurism.com/artificial-intelligence/burger-king-adding-ai-employees-headsets</a></p><p>Societal vs Market Benefit<br><a href="https://medium.com/mapculture/societal-versus-market-benefit-cff439595671">https://medium.com/mapculture/societal-versus-market-benefit-cff439595671</a></p><p>AI and the new theocracies<br><a href="https://medium.com/mapai/ai-and-the-new-theocracies-9b573eb9ab1b">https://medium.com/mapai/ai-and-the-new-theocracies-9b573eb9ab1b</a></p><p>AI headbands tracking student attention levels suspended amidst online controversy<br><a href="https://en.people.cn/n3/2019/1101/c90000-9628768.html">https://en.people.cn/n3/2019/1101/c90000-9628768.html</a></p><p>Chinese primary school halts trial of device that monitors pupils’ brainwaves<br><a href="https://www.theguardian.com/world/2019/nov/01/chinese-primary-school-halts-trial-of-device-that-monitors-pupils-brainwaves">https://www.theguardian.com/world/2019/nov/01/chinese-primary-school-halts-trial-of-device-that-monitors-pupils-brainwaves</a></p><p>BrainCo<br><a href="https://www.brainco.tech/">https://www.brainco.tech/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=53e815e2afe7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/mapculture/brave-new-world-53e815e2afe7">Brave New World</a> was originally published in <a href="https://medium.com/mapculture">MapCulture</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A moment of reflection]]></title>
            <link>https://swardley.medium.com/a-moment-of-reflection-f401c5d848dc?source=rss-280dd9543ba9------2</link>
            <guid isPermaLink="false">https://medium.com/p/f401c5d848dc</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <category><![CDATA[wardley-maps]]></category>
            <dc:creator><![CDATA[swardley]]></dc:creator>
            <pubDate>Thu, 19 Feb 2026 18:23:04 GMT</pubDate>
            <atom:updated>2026-02-19T18:46:46.934Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<h4>On vibe coding, context and open source</h4><p>In 2023, I wrote a short series of posts about the AI / vibe coding space. These were subjects that I have covered in various talks over the last decade but I’d like to take a moment to reflect.</p><p>The first post (see background) was on the importance of conversational programming. Whilst this has been a hot topic subject since 2016, I would constantly repeat<em> “It’s not widely talked about yet, but it will be”</em>. In 2023, we were <em>“still waiting for those conversational programming environments to fully form but we’re getting close”</em> i.e. we were right on the edge, the sub components were there, the first examples had been in circulation from <a href="https://www.linkedin.com/in/simalexan?miniProfileUrn=urn%3Ali%3Afs_miniProfile%3AACoAAAWgY5EBcLDWpXQodD8KLrbX-E4SbrfHATQ">Aleksandar Simovic</a> demo at AWS RE:Invent to GitHub’s Copilot.</p><p>However, as I often remind people these changes require CAST — concept, attitude, suitability and technology. The concept of conversational programming had been there for a long time, since the days of Graphical Conversation Theory and Architecture by Yourself by Nicolas Negroponte. The attitude was there, lots of people felt frustrated at how difficult it was to get something developed. The technology was increasingly there, LLMs/GPTs were rapidly becoming commodity like. We just needed some further improvements (suitability) and the spark.</p><p>That spark came when Andrej Karpathy coined the term “vibe coding” in 2025. The entire field exploded onto the scene … along with the inevitable and tiresome myths (listed in that post). It has been glorious to watch though, a re-run of previous cycles such as serverless, cloud … all the way back to the industrial revolution. Yes, I had the tedious trolls saying it was different this time but then they always say that, and then quietly disappear later. The only real difference is the blast radius of the change i.e. how many value chains does it impact? Vibe coding is big, maybe not as big as SpimeScript will be (or what you might call cyber digital) but that’s a future topic, not for now.</p><p>There is however, still a long way to go. For example, practices need to co-evolve and are still emerging. Which brings me onto the second post, the importance of context or what I called “Maps as code”. There are a lot of thorny issues here including human reasoning, the chain of comprehension that exists, the embedding of values in a system (which has implications for sovereignty) and the general lack of situational awareness.</p><p>As I said in that post:</p><blockquote><em>“Github CoPilot are admirable but probably in the wrong space. I think the breathless horde of consultants prognosticating the replacement of programmers with LLMs have fallen into a trap, not dissimilar to their claims in 2011 of cloud saving you money”</em></blockquote><p>The problem for me is the medium. The issue itself is code as text, and how we visualise the space or more importantly how we fail to visualise the problem space. That is not a problem with AI but instead :</p><blockquote><em>“It doesn’t matter if it’s written or spoken, the medium is still the word, it is text. The power of conversational programming will only be truly unleashed if we can escape from the confines of text (where syntax, styles and rules dominate) and into a world of maps (where things, relationships and context matters).”</em></blockquote><p>This is one of the reasons why I’m writing Rewilding Software Engineering with <a href="https://www.linkedin.com/in/girba?miniProfileUrn=urn%3Ali%3Afs_miniProfile%3AACoAAAC-kuUBUYowjuoq_XCc5wr1uvXY4RhQOXk">Tudor Girba</a>. I cannot emphasise enough the importance of examples (in development) and visualisation of context. Our current toolsets are flawed in my opinion, most lacking any contextual views because most tools are not contextual to the problem that you are trying to solve. In terms of context, I’ve seen modest improvements over the years, at least some are talking about it as a big thing but most get bogged down in knowledge graphs and the ideas of modifying standardised tools with this. They are missing the forest for the trees.</p><p>The third and final post was on the importance of open source in this space. I won’t hide that I was severely disappointed where we were in 2023, especially with the focus on guard rails and the AI safety summit. My anger spilt over in that post:</p><blockquote><em>“Laughably, the UK led an AI safety summit last week. I say laugh, but if you’re in the UK then you might want to cry, especially given so many voices were ignored. You would have thought that handing over national sovereignty in the landscape of technology to a few would be THE major safety issue. Apparently not. The ‘great and good’, and lobbyists talking up ‘responsible AI’ seemed focused on saving us from some future mythical frontier AI. I’m guessing they were all traumatised as younger children by James Cameron.”</em></blockquote><p>To be blunt, not much seemed to be improving, we’ve had the weak Open Source AI definition from OSI (where data is not considered part of the set of symbolic instructions and caveats are given to sufficiently detailed information) but set against this we have fortunately seen France and more importantly China’s moves into this space. I am however encouraged with the recent announcements by <a href="https://www.linkedin.com/in/kanishka-narayan?miniProfileUrn=urn%3Ali%3Afs_miniProfile%3AACoAAAa1mUoBkkiN4JN3eaV01TsA3EnTwlJAtBI">Kanishka Narayan MP</a>.</p><p>Finally, the UK might be getting into the game.</p><p>Overall, the progress has not been too bad. In terms of context, that’s still far slower than I would have hoped by now but when it comes to practices, these normally take 5 to 8 years to emerge and stabilise.</p><h3>Background</h3><p>Jan, 2023 — What is conversational programming? — <a href="https://medium.com/@swardley/why-the-fuss-about-conversational-programming-60c8d1908237">https://medium.com/@swardley/why-the-fuss-about-conversational-programming-60c8d1908237</a></p><p>May, 2023 — Maps as Code — <a href="https://medium.com/mapai/why-the-fuss-about-conversational-programming-70a8b7ca0d2b">https://medium.com/mapai/why-the-fuss-about-conversational-programming-70a8b7ca0d2b</a></p><p>Nov, 2023 — Why open source AI matters — <a href="https://medium.com/mapai/why-open-source-ai-matters-a46a7d23ad0e">https://medium.com/mapai/why-open-source-ai-matters-a46a7d23ad0e</a></p><p>Rewilding Software Engineering -<a href="https://moldabledevelopment.com/">https://moldabledevelopment.com/</a></p><p>UK AI Minister Kanishka Narayan MP supports OpenUK and open source -<a href="https://www.linkedin.com/posts/openuktechnology_indiaaiimpactsummit2026-indiaai-opensourceai-activity-7430266584134377473-Yk0F">https://www.linkedin.com/posts/openuktechnology_indiaaiimpactsummit2026-indiaai-opensourceai-activity-7430266584134377473-Yk0F</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f401c5d848dc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[On the question of debt]]></title>
            <link>https://medium.com/mapai/on-the-question-of-debt-aca1125d4a62?source=rss-280dd9543ba9------2</link>
            <guid isPermaLink="false">https://medium.com/p/aca1125d4a62</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <category><![CDATA[technical-debt]]></category>
            <category><![CDATA[wardley-maps]]></category>
            <dc:creator><![CDATA[swardley]]></dc:creator>
            <pubDate>Sun, 15 Feb 2026 13:42:32 GMT</pubDate>
            <atom:updated>2026-02-15T17:06:33.637Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<p>When dealing with systems, there are four types of debt that I tend to consider — technical (code), evolutionary (value chain), cognitive (reasoning) and epistemic (understanding). They also share a common structure of shorter term optimisation (with any benefits that brings) at the expense of longer term resilience.</p><p>They are a trade-off, they all borrow from the future to spend now.</p><h3>Technical debt</h3><p><strong>Common meaning</strong>: Technical debt is a qualitative description of the cost to maintain a system that is attributable to choosing an expedient solution for its development. While an expedited solution can accelerate development in the short term, new understanding is often gained by the building and running of the system. Without restructuring, the result may increase future costs if left unresolved.</p><p><em>Note</em>: Ward Cunningham took a complex, multi-dimensional problem and reduced it to a single scalar that business could grasp. The code represents what the system does (function) and how it does it (structure). But that code exists within an environment, and is shaped by the skills and tools used to build, operate, and understand it. What we are really dealing with is a tensor of function, structure, context, skills, and tools, compressed into a single scalar called “technical debt”, a value that people then often attempt to “measure” by examining structure alone. By changing one of the other variables in the tensor (such as tools, skills or context) it is possible to reduce such debt e.g. with automatic refactoring.</p><p>For more on this topic, see see Myth 8 in <a href="https://medium.com/feenk/rewilding-software-engineering-ca3ad1e612d8">https://medium.com/feenk/rewilding-software-engineering-ca3ad1e612d8</a></p><h3>Evolutionary debt</h3><p><strong>Emerging meaning</strong>: the strategic cost you incur by failing to evolve a value chain component along its natural lifecycle as markets mature over time.</p><p><em>Note</em>: Examples include custom building a thing which is already a commodity. This often manifests itself in organisational misalignment such as governance or practices being misapplied or failing to co-evolve with the technology. Commonly caused by not looking at an environment (short term optimisation) before taking action.</p><p>This debt often manifests itself as inertia. This is covered in <a href="https://medium.com/wardleymaps">Wardley Maps</a> in Chapter 10, “I wasn’t expecting that”<br><a href="https://medium.com/wardleymaps/i-wasnt-expecting-that-dcfe122a2234">https://medium.com/wardleymaps/i-wasnt-expecting-that-dcfe122a2234</a></p><p>A useful glossary of terms, see <a href="https://www.wardleymaps.com/glossary/inertia">https://www.wardleymaps.com/glossary/inertia</a></p><h3>Cognitive debt</h3><p><strong>Emerging meaning</strong>: the long term, compounding cost to human intelligence, memory, and critical thinking that accumulates when we substitute rather than augment our reasoning.</p><p><em>Note</em>: It represents a decline in cognitive independence and is a trade-off between immediate convenience and longer term skill development including critical thinking. It operates at the individual level. Often seen with extensive use of LLM/GPTs.</p><p>An excellent introduction is found in “Your Brain on ChatGPT: Accumulation of Cognitive Debt when Using an AI Assistant for Essay Writing Task” — <a href="https://arxiv.org/pdf/2506.08872">https://arxiv.org/pdf/2506.08872</a></p><h3>Epistemic debt</h3><p><strong>Emerging meaning</strong>: the hidden, long term cost incurred when systems are implemented without a full understanding of how they work, creating a gap between system complexity and human comprehension.</p><p><em>Note</em>: Knowledge of how they work does not need to be held by one person but can be maintained in a chain of comprehension with many actors (including vendors). The debt represents “unearned” knowledge that functions temporarily but leads to high maintenance risks and fragility. It operates at the organisational level and is rapidly growing through use of LLM/GPTs e.g. vibe coding.</p><p>See “Epistemic Debt: A Concept and Measure of Technical Ignorance in Smart Manufacturing” — <a href="https://link.springer.com/chapter/10.1007/978-3-030-20040-4_8">https://link.springer.com/chapter/10.1007/978-3-030-20040-4_8</a></p><p>Or for a more general note, my post on LinkedIn — <a href="https://www.linkedin.com/posts/simonwardley_x-how-many-executives-are-looking-at-code-activity-7426577558827216897-5Y0G">https://www.linkedin.com/posts/simonwardley_x-how-many-executives-are-looking-at-code-activity-7426577558827216897-5Y0G</a></p><h3>Brave New World</h3><p>My concern with LLM/GPT generated code isn’t that developers are delegating because developers have always delegated to libraries, frameworks and even compilers. It’s that the delegation has extended to comprehension. There is no chain, just systems that cannot explain their reasoning beyond generating plausible sounding explanations for code it has already produced.</p><p>The reasoning and the understanding is lost. And without that, so is learning. We are building brick upon brick of epistemic debt, promising a future where success no longer depends upon anyone being able to reason about it, let alone understand it. With vibe coding, we’ve even gone so far as to celebrate this.</p><p>I can’t help but remember Quinn Norton’s warning <a href="https://medium.com/message/everything-is-broken-81e5f33a24e1">“Build it badly, and they will come”</a> and realise that everything is heading towards broken, including knowledge and our ability to reason. As Quinn said,</p><blockquote>“ the geeks and the executives and the agents and the military have fucked the world. But in the end, it’s the job of the people, working together, to unfuck it.”</blockquote><p>That will become a lot more difficult as we lose the ability to reason and understand the systems around us.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*quLzoKAIeJmLDcNOIWj38w.jpeg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aca1125d4a62" width="1" height="1" alt=""><hr><p><a href="https://medium.com/mapai/on-the-question-of-debt-aca1125d4a62">On the question of debt</a> was originally published in <a href="https://medium.com/mapai">MapAI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Rewilding Software Engineering]]></title>
            <link>https://medium.com/feenk/rewilding-software-engineering-ca3ad1e612d8?source=rss-280dd9543ba9------2</link>
            <guid isPermaLink="false">https://medium.com/p/ca3ad1e612d8</guid>
            <category><![CDATA[legacy]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[technical-debt]]></category>
            <dc:creator><![CDATA[swardley]]></dc:creator>
            <pubDate>Fri, 16 Jan 2026 18:35:37 GMT</pubDate>
            <atom:updated>2026-10-08T21:48:23.336Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-nc-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<h4>Chapter 6: Myths we tell ourselves</h4><p><em>By Tudor Girba and Simon Wardley</em></p><p>Software is a domain of mostly invisible knowledge work. It’s hard to see progress, quality or risks in the way that you can with building bridges or running a factory. In that vacuum, simple narratives often fill the gap. As Alan Kay said “computing has turned into a pop culture” and many of its most popular stories have become myths … “the 10x engineer”, “the genius founder”, “move fast and break things!”. In this chapter, we wish to explore specific myths focused on software engineering itself.</p><h3>Myth 1: Software engineering is about building functionality</h3><p>When we talk about building functionality, we mean writing code with the goal of transforming an input into an output that conforms to some specification. In chapter 4, we described how seven teams were tasked with producing a calendar application. Whilst their output was functionally equivalent, the internals were quite different. This is illustrated in figure 50, which visualizes the structure of each system in terms of code entities and their relationships.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yTqVWIr076HsI1b2fXCbyQ.png" /><figcaption><em>Figure 50 — Seven examples of a calendar application</em></figcaption></figure><p>The experiment shows that when we constrain functionality (through specification and tests) without constraining structure then this can lead to functionally equivalent but structurally diverse solutions. In other words, the structure can evolve independently of the functionality.</p><p>But why does structure matter? Isn’t it enough for a system to meet the required functionality? The short answer is that it is until it isn’t. The longer answer requires us to understand a little about evolution.</p><p>Our systems are built within a context, an economic and technological landscape. That landscape might appear to be static at a single point in time, but in practice it is constantly evolving. Take how our supermarkets have used bar codes to automate away the manual process of cashiers reading price labels that were stuck on products with label guns. The other technological systems (such as inventory or accounting) that the supermarkets used had to accommodate this new concept. The ability of a system to adapt to a change depends upon the structure of the existing system and not its existing functionality.</p><p>To demonstrate this point, let us return to our seven calendar applications. Let us suppose some unpredictable event (as bizarre as barcodes would have seemed in the 1950s) has happened to the environment and the weekly calendar now includes ten days (as happened in the French Revolution, 1793 to 1805). This would require a change to those systems. The difficulty in changing them would not depend upon the existing functionality (which they all fulfill) nor the new functionality (which they all would have to comply with). It will depend upon the existing structure that has been built into each. In some cases, the change might be trivial to implement. In other cases it would involve large structural changes.</p><p>Rather than changing the number of days in the week, let us pick something more commonplace such as splitting our monolith calendar application into two parts so that you can scale them differently. Such an activity depends almost exclusively on the structure of the system. Consider the case in which we are in team A which is working on the system depicted at the bottom-right of our visualization (figure 51). Cutting it in the middle crosses only a few dependencies. The situation for team B (top-left) looks radically different: cutting in the middle crosses many more dependencies of the system.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AAaUXgR1q_XKeT_iIHl9og.png" /><figcaption>Figure 51 — Splitting two systems</figcaption></figure><p>In summary, software engineering is more than just functionality, it also includes structure. Some structures facilitate the creation of new functionality better than others.</p><p>This is why concepts like refactoring (or restructuring, in general) are important. Avoidance of refactoring inevitably leads to systems that are out of date with their landscape and difficult to change. These we tend to call “legacy” which is just another way of saying that we have a structure that is stuck in the past which makes it difficult for us to change.</p><p>To solve the legacy problem we have to invest in refactoring. Unfortunately, such activity tends to be costly because we not only have to rewrite the structure, we first have to understand it. To make matters worse, this cost rises over time especially if new teams unfamiliar with the system are brought in and start their journey by reading code. To compound this further, there is often pressure to spend resources on adding new functionality rather than dealing with the structure. As a consequence of this, dealing with the structure is often left until the legacy problem is upon us. At which point, the high cost of changing a software system’s structure can be observed in the large number of failed modernizations.</p><p>To solve this problem, we need to somehow make refactoring inexpensive. In the digital world, the structure, the functionality, the tools and even the environment itself are constructed from code. We can therefore apply the concept of automation to refactoring.</p><p>This does occur but in most environments automatic refactorings only work on a small scale e.g., changing the name of a variable or moving a method. In 2010, Brant &amp; Roberts et al showed that automatic transformation could work at a large scale with a case study of migrating a system of 1.5M lines of Delphi code into C# . Their work shows that large transformations can be achieved systematically through many micro automatic transformations that can be developed almost independently. We expand on these ideas later, but for now it is enough to note that software engineering is more than building and includes refactoring, and it is more than functionality and includes structure.</p><h3>Myth 2: Refactoring is not a business problem</h3><p>Most systems that support human processes and decision making have replaced what once happened manually. That human work used to be called knowledge work. It is, therefore, suitable to describe systems by the knowledge they encode and how they encode it.</p><p>The system’s functionality represents what the system accomplishes as a result of this encoded knowledge. The system’s structure represents that encoded knowledge in terms of the mechanics of how things are transformed. Some structures facilitate change better than others.</p><p>So what?</p><p>In the past, the core knowledge of an organization was contained in the heads of people and in the processes they followed. The knowledge management movement made the importance of processes more prominent. The idea was that new value can be created by exploiting the existing knowledge either by streamlining work or by combining it in new ways. Today, much of this core knowledge is inside of the structure of software systems. It is not in documents, it is not in people’s minds, it is inside the systems. That knowledge is still critical to organizations, and both streamlining and recombining are sources of value creation.</p><p>The importance of understanding the inside of systems can be observed in what engineers do. Most spend their energy not on writing code but in figuring out the knowledge encoded in the system to learn why, what and how to change things.</p><p>Let us demonstrate this with an example. At the height of the 2020 pandemic, a large national retailer (with annual revenues in excess of $10bn) decided it was strategically important to strengthen their online offering. At the core of their ecosystem, they had an old database containing customer information to which different applications were connected for read and write purposes. They wanted to have a more granular customer model and to migrate the database to a system that could be accessed via an API.</p><p>The project was defined and a significant team with resources were added. Their initial approach to deal with this had been to ask application teams about their needs. They then asked a couple of those teams to start isolating the calls to the database through a thin microservices layer (this is known as the strangler pattern). That seemed to work well at first, but six months into the project, they realized they still did not know which surrounding systems were using the database, let alone what changes should be performed.</p><p>In other words, half a year into a key strategic initiative they still did not have the first order information about the problem space. The knowledge was somewhere in their technology ecosystem, but they lacked the ability to decode it. They turned to outside expertise and brought in a team to help with that decoding. This is where things went from bad to worse.</p><p>To reason about the encoded knowledge within a system, you need access to the code. When asked for the code sources of the potential systems it turned out that they did not even know where the code for most of the systems was. The only known piece was the database itself and the few new microservices that were intended to wrap the database. You might find this surprising given the size of the company, alas, it’s all too common.</p><p>They could depict the situation in a diagram as seen on the left hand-side of figure 52: a central database (red) with systems (black) that were accessing it either directly or through services (blue). That was good enough to start from. The sysadmins then instrumented both the database and the microservices for a day (which was their typical business cycle) to gather fine grained logs. The logs contained all the queries over the database and the services, including the IP address of the machine performing the call. The logs were analyzed through multiple contextual tools that sliced and diced the information and later linked it with other sources of data. The automatic overview of the system is shown on the right.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*E-jcoE7OuugjYrQiegsCcw.png" /><figcaption>Figure 52 — Manual depiction of what people believe the system was vs what the system actually was</figcaption></figure><p>This view (one of many created) shows in red the tables from the database, in blue the services and in black the systems. From here they could identify that not all systems have the same needs. For example, while some systems used tables in isolation, others relied on common tables. Thus the picture informed not only which systems have to change, but also provided input into how the work should be organized: which teams can continue working independently, and which should coordinate.</p><p>It’s worth taking a moment to look at the figure. The company had spent six months trying to understand what it had and despite all this effort, the left hand side was the best representation that they could provide. On the right hand side is what the actual system was and it took two people and one month to produce.</p><p>The challenge with this refactoring wasn’t in writing code, it was in understanding the encoded knowledge. That knowledge was in the system, not in people’s heads or in documentation. Tools were needed to unearth it but those tools had to be contextual to the system being examined.</p><p>Without this decoding, the organization could not execute at the business level. Hence whilst it might be commonplace to think of software refactoring as a technical activity about rewriting code, it often turns out to be a business activity about reshaping encoded knowledge.</p><h3>Myth 3: Software engineering is an engineering practice</h3><p>Software engineering should be an engineering discipline. But, most of it is still a craft. We should learn from the parts that are more evolved. Let us examine two major parts: development and testing. Let us start with testing.</p><p>There used to be a time when the decision to release a system undertook an elaborate process involving quality gates, manual attempts at regression testing and quality managers. People would define what quality means, other people would create checklists and then manually go through these. At the end, a report would be compiled with the results and someone would decide whether to release or not. The decision of whether the system fulfills the desired goal was long, laborious, and often wrong.</p><p>Granted, not all testing was manual. People aimed to automate the process with systems like SIMMON as early as the 1960s. In the same way how the price labeling in supermarkets has changed through automation, such a system removed the manual effort from the tedious part of testing. It was only much later that Kent Beck and Ward Cunningham realized we don’t have to wait until the end of the project before testing it, we could automate testing throughout the construction of the project. This eventually culminated in the ideas of test driven development (TDD) where we built the test for a system prior to writing the code that passed the test. This was a remarkable evolution.</p><p>Let’s explore it in more detail by looking at the topic through our map of decision making (our first wolf), and follow the path for testing. We begin with a hypothesis that the system lacks a feature and we build a test to check for this. That test is part of a systematic mechanism of exploring the space using a model created by the tests. If you’ve ever heard someone say “the best specification is the test suite” then this is what they mean, the tests model the system. The output (information) of those tests are traffic lights synthetized from specific coding. The overall experience is provided by the test suite which is composed of thousands of micro tests. When approached in this way, software testing is very firmly an engineering practice (see figure 53).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dwRtfscOq5cI1PAweAIocQ.png" /><figcaption>Figure 53 — Testing as an engineering discipline</figcaption></figure><p>Let us summarize the changes in testing. In the early days of the industry, testing used to favor a gut feel driven approach. Traditional development handed code to testers who lacked system understanding and had to guess how things worked. Test-driven development (TDD) transformed testing from guesswork into an engineering discipline by embedding understanding directly into test suites which were made out of thousands of small, contextual tests that captured the system model and domain knowledge. TDD is more than just a testing technique, it’s a way of designing. But there is still more to this picture that’s worth understanding.</p><p>TDD sees the system in terms of functionality, inputs and outputs. As we’ve seen in myth 1, this point of view misses structure. To show this, let us examine the red-green-refactor cycle of TDD in more detail. The first step (red) is to write the test to show what needs to be done. This works great when we start with a known wish about the system that we can transform into a setup and an assertion. However, there are situations in which this is not possible because we do not know what a good assertion can be. For example, when we have to make sense of some data that we’ve never seen before, we cannot formulate a meaningful hypothesis upfront. We have to explore the data first. Similarly, green (implementation) is fine but how do we know what to implement? And what about the refactor step? How do we know what and how to refactor, and more importantly, how do we know when to stop? It’s not enough to guide the system through tests, you need to see the system as well. All of these questions lead us into development.</p><p>The limits of TDD don’t mean that development can’t learn from TDD. What might be less obvious to the reader is that those small tests used in TDD are in fact highly contextual tools i.e. they have inputs and outputs and they are applied to a specific problem (the test scenario). Every question about a system boils down to retrieving information from it. To decrease the time to answer, we need tools. But as software systems are highly contextual (an electronic healthcare record system is not the same as an online gambling site), surely we need our tools to be contextual, too. This leads to a question: What happens if we apply testing’s solution of using contextual tools to all development problems?</p><p>To answer that question, we need to look at how development is actually done today. Let us assume our organisation uses TDD (and sadly, that’s not everyone, for many testing is still a craft), once we run our tests and see it fails we switch to development in order to fix the problem. For most that means grabbing our monolithic coding environment (which we use for every problem), we inspect the code (often through reading) and we manually gather information to explain the problem (from architectural diagrams to logs). We like this because we want to be “data centric” but then most of those diagrams are actually statements of belief rather than fact. Our exploration is somewhat ad-hoc until we reach a point that our gut tells us that this is the right solution. We try it, we run the test again. For most, software development is very much in the craft phase (see figure 54).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e_tQncs0xKypG43vuz9SMQ.png" /><figcaption>Figure 54 — Development as a craft</figcaption></figure><p>If we want to change software development into an engineering practice then we have to follow that journey of testing. We have to start at the bottom of the map, with the foundations — the development experience. Tests are small tools built for our context. For software development, our experience should also mimic this with thousands of small tools molded to fit our problem. This allows us to climb the value chain all the way up to being hypothesis driven. This is the only path for development to become an engineering subject and it’s why it is our second wolf.</p><p>It’s worth reiterating once again what our two wolves are:</p><p>Wolf 1: Challenging the way we view software engineering and demonstrating that it is primarily a decision making process.</p><p>Wolf 2: Challenging the way in which we ask and answer questions and demonstrating that we need contextual tools.</p><p>Alas, tool vendors are trying to sell us the same tools everywhere with an added sheen of LLMs under the argument that AI is better at software creation than most people are. Well, in cases that might be true if we limit software development to a craft and never turn it into an engineering practice and optimize it. When we’ve seen groups take software development from a craft to an engineering practice (by abandoning those monolithic tools, even the ones with added LLMs) then we’ve seen performance increases of orders of magnitude and not the paltry benefits claimed by AI vendors.</p><p>Of course, this isn’t an exclusive choice though. Development becomes even faster when you start to use LLMs to build those contextual tools for you. By understanding both of our wolves this new path becomes possible.</p><h3>Myth 4: LLMs will replace software engineers</h3><p>We could talk about the endless prognostications of the great and good about how software engineers will disappear through vibe coding, but Simon has already covered the usual sort of myths in his medium posts from January 2023. Frankly, after two and a half years of this nonsense, both of us are bored rigid with it. However, for completeness, we will just repeat some of them here and move onto the more interesting topic.</p><blockquote><em>1) You’ll need less engineers. Nope. See Jevon’s paradox. You’ll need to retrain to a new world but you’ll end up doing more stuff.</em></blockquote><blockquote><em>2) It’ll reduce IT budgets. Nope. See Jevon’s paradox again. You’ll end up doing more stuff, more cost efficiently.</em></blockquote><blockquote><em>3) You have a choice. Nope. See Red Queen Effect. This is only a question of “when” not “if”.</em></blockquote><p>Now we are done with the dull, let us talk about a more interesting path which also appears in Simon’s article, the link between LLM and software engineering.</p><blockquote><em>6) I can make a more efficient application by hand crafting the code. Nope. Well, technically you can but the time taken to hand craft it all will be vast compared to the speed at which competitors will move. I’d also suggest reading into Centaur Chess if you think even the most gifted engineer will outcompete an average engineer with an average AI.</em></blockquote><p>Rather than rushing to get rid of software engineers, try instead getting rid of standard tools (even those with added LLMs) and focus on using LLMs to help compose your development experience out of thousands of micro tools just like testing. In the same way we have a test suite that is designed for a specific problem with small tests, we should have a tool suite for our application built out of micro tools.</p><p>By using LLMs in this way, we simultaneously turn development into an engineering subject and gain the benefits of LLMs in two areas where they are strong — creation of hypotheses and creation of specific coding for contextual tools (see figure 55).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N3E61Fj-3HrM7aEc8yUK1Q.png" /><figcaption>Figure 55 — Development as an engineering discipline</figcaption></figure><p>Those are fancy words but a practical example of this way forward would be better. So, let us start by using LLM to analyze the Glamorous Toolkit. Trying to understand a system is a common problem faced by every developer when looking at a legacy environment.</p><p>We ask the LLM to provide us with a list of components and relationships. We give it the context of the code base, and we provide it with tools to search and retrieve code. We ensure that it knows about the specifics of how dependencies are defined. And we nudge the LLM to traverse the dependencies recursively and produce a systematic output in the form of the name of the component and its direct dependencies.</p><pre>Find all components and their direct dependencies from Glamorous Toolkit.<br>For this you should:<br>- Traverse all dependencies recursively to identify all components starting from the root one.<br>- Provide the result concisely in the form of an array.<br>- An item in the resulting array is made out of an association between a key in the form of the name of a component, and the value made of an array with the names of only the component&#39;s direct dependencies.<br>- List all referred projects regardless of whether they are considered internal or external.<br>- Not list the recursive dependencies.<br>- Not list dependencies to packages as they are internal to projects.<br><br>The result should look as below:<br>```<br>{<br>&#39;ComponentA&#39; -&gt; { &#39;ComponentB&#39; . &#39;ComponentC&#39; }.<br>&#39;ComponentB&#39; -&gt; { &#39;ComponentE&#39; }<br>}<br>```</pre><p>To make the experiment as representative as possible, we picked a problem for which the LLM would have to explore the system whilst still relying upon prior knowledge for how dependencies are declared. We needed to test this because if the LLM didn’t know about how dependencies are declared then that would have introduced a confounding variable to the experiment.</p><p>We validated this setup by not telling it where or how to find the dependencies. The plan produced by the LLM confirmed that it did know those details:</p><pre>Plan to build the dependency map:<br>- Find GT root baselines: search for classes named BaselineOf* that include &#39;GToolkit&#39; or &#39;GlamorousToolkit&#39;.<br>- For each root baseline, extract direct dependencies from its #baseline: method (look for spec baseline:/project: entries).<br>- Resolve each dependency to a local BaselineOf* class when present; keep the name string otherwise.<br>- Traverse recursively to discover all reachable components, but record only direct dependencies per component.<br>- Output a sorted array of associations: &#39;Component&#39; -&gt; { &#39;DirectDep1&#39; . &#39;DirectDep2&#39; }.<br>Proceed?</pre><p>And then it produced a result with 154 components and 243 dependencies. It did so by querying and traversing the code as described in the plan. Quite impressive.</p><p>Of course, we do not need the LLM to answer such questions in the Glamorous Toolkit because we already have deterministic contextual tools that provide accurate answers. So, what’s the difference between the LLM answer and the one coming from our contextual tools? That’s a task for another tool and the result is figure 56 which shows a graph of components and their dependencies in which:</p><ul><li>the components and dependencies that both occur in the system and were correctly detected by the LLM appear in black;</li><li>the components and dependencies that were missed by the LLM are colored in red.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PH7hQTma104yN-sS3o5x6A.png" /><figcaption>Figure 56 — A visualization of the Glamorous Toolkit components and their dependencies</figcaption></figure><p>The experiment shows us that the approach of using an LLM to understand a system, whilst convincing, fails. The result misses components, misses relationships and even shows relationships that do not exist. This is inevitable with any statistically based engine, particularly as the scale of the problem increases. What you need to remember is LLMs are not truth engines but coherence engines. They do not give you “what is” but “what is likely and sounds coherent”.</p><p>Armed with the results, we went ahead and tweaked the prompt in the hope that we could get the LLM to be more accurate. And in some cases it worked better. The emphasis here is on <em>some</em>.</p><p>Given a medium system with 1.6 million lines of code, 194 core components and 396 direct dependencies, the error rate of the LLM is roughly 5% to 30% of the components and dependencies missing along with components hallucinated. The problem is not so much the actual error rate (let us say 10% for example) but that you don’t know what 10% is wrong unless you have contextual tools (which most systems don’t) and if you had contextual tools then you’d simply run the tool. The only way to verify the LLM results in environments that lack contextual tools is through manual inspection which never happens because it is the very problem people are trying to circumvent. Even if it does happen, it is highly likely that significant errors will slip through any manual inspection.</p><p>It’s just not the error rate that is shocking, it’s also the cost associated with it. Once the contextual tool is created the cost to discover what the architecture is, what components are used and what relationships exist is barely measurable and constantly repeatable, capturing any and all modifications. The running of an LLM was orders of magnitude slower, more expensive (even at today’s highly subsidized prices) and humongously more error prone.</p><p>The LLM will give you an output that looks like an answer, it will do this more quickly than you can read the code but what it provides should not be used in an engineering context — it will lack those essential three characteristics of being representative, accurate or even explainable. Relying on this becomes a matter of faith.</p><p>The way to positively overcome the limitation of LLMs and not rely on blind faith, is to use the LLM to help generate the specific coding (the tool) that will provide the information we seek. This is our “way forward”. In this part of the example, we show you how to do this.</p><p>We start with our original prompt but change the first paragraph so that rather than giving us the answer directly, it gives us a snippet of code (a tool) to do this:</p><pre>Produce a snippet that recovers all components and their direct dependencies <br>from Glamorous Toolkit. The code should:<br>- Traverse all dependencies recursively to identify all components starting from the root one.<br>- Provide the result concisely in the form of an array.<br>- An item in the resulting array is made out of an association between a key in the form of the name of a component, and the value made of an array with the names of only the component&#39;s direct dependencies.<br>- List all referred projects regardless of whether they are considered internal or external.<br>- Not list the recursive dependencies.<br>- Not list dependencies to packages as they are internal to projects.<br>The result should look as below:<br>```<br>{<br>&#39;ComponentA&#39; -&gt; { &#39;ComponentB&#39; . &#39;ComponentC&#39; }.<br>&#39;ComponentB&#39; -&gt; { &#39;ComponentE&#39; }<br>}<br>```</pre><p>With this simple change, instead of getting data, we now get code that’s meant to retrieve it. In our case, the LLM produced the following snippet:</p><pre>&quot;Collect all GToolkit components and their direct dependencies&quot;<br>| repo builder rootProject allProjects |<br>repo := &#39;github://feenkcom/gtoolkit:main/src&#39;.<br>builder := GtRlDependenciesModelBuilder new.<br>rootProject := builder<br>buildProjectFromBaselineClass: BaselineOfGToolkit<br>withRepositoryDescription: repo.<br>allProjects := rootProject withAllChildProjects.<br>allProjects collect: [ :project |<br>project name -&gt; ((project projectReferences collect: [ :ref | ref <br>referencedProject name ]) asArray) ]</pre><p>Executing the code produced the correct answer. It worked on the first and subsequent tries. You still need to review the code of the snippet itself, however, reviewing ten lines of coding in a tool is less daunting than manually finding and inspecting 194 component descriptions hidden inside a 1.6 million lines of code system. This works particularly well because we are facing a shallow problem.</p><p>The obvious counter from AI purists is to point out that we can use one agent to create a tool and another agent to understand. That’s fine but then you’re eliminating any human path to understanding and you are delegating the decision to the agent. This is a question of architecture.</p><h3>Myth 5: Architects make decisions</h3><p>In the previous myth, we showed a practical example of using micro tools with LLMs to expose the architecture of Glamorous Toolkit. We want you to take a good look at figure 52. Does that look like any normal architectural diagram that you’ve seen before?</p><p>In the world of moldable development, architectural diagrams that are generated out of the system itself are the norm. But they don’t look like diagrams you commonly see on whiteboards or powerpoint slides that aim to describe the existing systems. This is because those traditional diagrams are statements of belief i.e. what we would like the architecture of the current system to be and not what the architecture is.</p><p>Whatever you might prefer to understand by architecture, the only architecture that matters in software is the one that gets in the code. Thus the only architects that matter in the end are those that affect the code. Everyone else are wishful thinkers and potential influencers. It’s not architects that make decisions but the developer writing the code.</p><p>When the architecture is an emerging property, evolving it involves three activities:</p><ol><li>Know where you are</li><li>Choose where to go</li><li>Ensure you go there</li></ol><p>Of these, only the second involves design. The first and the third are assessment activities and they require visibility into the system (see figure 57).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J1dq1gsnjOCgjuBy4XTVag.png" /><figcaption>Figure 57 — navigating the architectural space.</figcaption></figure><p>The lack of vision into the system can lead to a difficult situation where a coder leaves the organization and a critical system is neither understood nor any documentation is accurate. Without the ability to generate the architectural diagrams from the system then the response by later developers is normally one of fear, not wanting to change or break anything in a system which is poorly understood but critical.</p><p>It is little wonder that there is a new lucrative market of vendors promising tools to understand your legacy through the use of LLMs. Their narrative exploits this fear but hopefully we have shown you in the practical example why their promises will rarely be met and that there exists a better alternative.</p><h4>But can’t we just use agents? I write an architectural diagram, one agent codes it, another checks that it has been coded correctly?</h4><p>Agents, being LLMs, have the same problems of hallucination and interpretation of your prompts. However, this is little different to human agents and at least in agentic swarms we are adding a process similar to building control that is found in physical architecture i.e. checking the code matches the diagram. In a sense by layering on multiple layers of agents you can clearly make an improvement in ensuring the code matches the architectural diagram. But, this is all wasted effort if you can simply get the system to generate its own architectural visualization to detect the delta between what is wished and what exists.</p><h4>But I could use a specification and get swarms of agents to build that?</h4><p>In the past, we fed programs into computers using things like punched cards, and on small micros you could even work directly in machine code or assembly. Take the once popular ZX80 which had Z80 chipset machine code and even higher level assemblers. These are languages close to the machine with hexadecimal commands such as 3E 2A (machine code) which means LD A, 42 (assembly) which means load register A with the number 42 (English enough for a technical person). Of course, if you were lucky enough to own a ZX80 then you used BASIC. You would type PRINT “HELLO” rather than “21 07 42 CD 0C 07 C9 2D 2A 31 31 34 01” (assuming a 4K RAM, rather than the 8K RAM with the ZX81, don’t ask).</p><p>We won’t continue with the metaphor, as it is giving both of us micro flashbacks to a time of fiddling with cassette tapes, listening for errors, wobbly RAM packs and typing in long strings of characters. It’s enough to say that the PRINT “HELLO” was more understandable.</p><p>The move to higher level languages, even a basic one like BASIC, made it possible to express ideas closer to how humans think and can better understand. These languages are executed on a machine, so the code eventually has to be translated to machine code. As that translation happens automatically with semantics guaranteed to be preserved, we no longer have to look at it, if we do not explicitly want to.</p><p>LLMs generate code, too. We can prompt “write a ZX80 program that prints hello” and the LLM readily produces PRINT “HELLO”. So, people concluded that we are facing a similar transition to a higher level of abstraction as we did when we moved from assembly to programming languages. Except that sometimes, our prompt produces PRINT AT 0,0;”HELLO” which looks similar but that clears the screen before printing. It’s not a large difference, but it is certainly not the same meaning.</p><p>What matters in this trivial example is that the semantics are not preserved. Unlike our translation from BASIC to machine language which always provides the same semantics (it is deterministic), the translation from prompt to machine language is not.</p><p>So, what does this mean in our current fad for specification driven development? It’s a bit like the calendar example above, yes you get an answer but the LLM could be acting like any one of those teams. You cannot guarantee that the semantics will be the same from one prompt to another. But isn’t that how real life is like? Yes, you don’t know what the team produces until you read the code in order to discover what decisions have actually been made. The specification alone is not enough. Unlike the translation from assembler to machine code, the translation from prompt to machine code moves the “developer” further away from the decision making in a material way.</p><p>Part of the problem, and why specification driven development sounds so seductive, comes from a misunderstanding of how we actually program things. The idea seems straightforward enough, in the physical world an architect creates a blueprint for a building and then the builder builds it. Following the construction metaphor in software engineering, the software architect creates a blueprint for the problem (the specification) and the engineer builds it! Almost, but not quite. Whilst we live in houses, we don’t live in the code that the engineer builds as there is a missing step. The computer translates the code and then runs the translation to provide the application. The code the developer produces is actually the blueprint. What we call software architecture (i.e. specification) is closer to a retail investors wishlist for new housing investment. Going from a retail investors wishlist to blueprints of the houses to be built takes a lot of decisions and those decisions are what code actually is.</p><p>This is not to say specification driven development isn’t useful, it certainly is as a learning tool. But we still have to decide the most important architectural question of where we value humans in the decision making process. If you’re happy handing over decisions to the machine then fine but you should do it being aware of the tradeoffs and the loss of comprehension.</p><p>But does losing control of system comprehension actually matter that much? It’s fine if you’re talking about prototypes, but if you’re going into production without that understanding, then you will increasingly be running the risk of becoming the next Knight Capital Group, a company that lost $440 million in 45 minutes because of behaviour within its systems that it did not understand. It’s only a matter of time before history repeats itself.</p><p>That’s not to say that human understanding is perfect; it’s not, as the Knight Capital example shows. It’s actually an argument for why good engineering practices matter. By choosing a path of devaluing human judgement in the decision making process, then you are accepting the structural choices and values the LLM uses as long as functionality seems correct. In doing so, you are ignoring that functionality is only one subset of what goes into building a system. Comprehension is your last line of defence in a world where we have not yet developed the engineering practices to manage this safely.</p><p>So let us now stretch the specification driven development to its next logical step. If we accept it as some higher level language (it is not) then why not get another agent to write the specification for you based upon some desired wish. Before some marketing person beats us to the punch, we will call this Wish Driven Development and quickly get an LLM to write us a book on this. We could even imagine prompting for “Build a successful product. Create a company around it. Reach an exit and deposit the amount in my crypto wallet”. Fame and fortune awaits!</p><p>Yes, you can even tell yourself that you’ll definitely read the specification this time before handing it to another swarm of agents to build it. You can snuggle under the comfort blanket that you have another swarm to check if the output matches the specification, another to build tests for it, to check if it is secure and so on. You can remove yourself far from the decision making processes and accept a world of convenience in return for no understanding. However, this is basically the storyline for E.M. Forster’s “The Machine Stops”, so he beat us to the punch by over one hundred years. Damn.</p><p>But hold on … why stop there, why not get the agents to create the desired wish? Do we really need humans to tell us what they want? The answers to all these questions is determined by where you think that humans should be involved in the decision making process and the nature of that involvement.</p><p>We’re not writing this to discourage people from using LLMs, quite the opposite. But we want you to think deeply about where you place human judgement in the decision making processes that are digital systems. Comprehension is not a nice to have. It is the scaffolding that makes safety, accountability, and learning possible. Without it, you are not engineering; you are relying on belief. By removing the conditions for comprehension under which mistakes can be understood, corrected, and learned from, you make the collapse that E.M.Forster discussed inevitable given enough time. In practice, we both suspect that it’ll take many Knight Capitals before we learn this lesson again, such is the seduction of LLMs.</p><p>To inform where human decision making matters, it is useful to know what humans can do through better engineering practices. Armed with that knowledge, we can then map the entire system and determine, for example, where do we wish to allow vibe coding for the creation of prototypes, where do we wish to use a combination of AI + Software Engineering (assuming we can make development an engineering subject) and where should we outsource to more utility providers. Remember, we are still learning the practices of how to do this safely but we should at least start by asking questions.</p><p>An example of this can be seen in figure 56. In this figure, we have taken a much earlier map used by James Findlay in the building of HS2 (UK high speed rail) in a virtual world. The original map was created in the early 2010s and was used to identify which system components should be built in a more agile way, which components should be bought off the shelf and which should be outsourced.</p><p>Today, on the same system map, we can ask a similar question on where human decision making matters. The answer is not a “one size fits all” but instead a combination. We might decide to vibe code those novel and new prototypes but simultaneously decide to use software engineering assisted by AI in building the core of the system. Where those boundaries exist will vary depending upon the capability of the technology, our willingness for risk and our requirements such as accuracy and reliability. The map is simply a communication tool for expressing this.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OK8tMVK9aMHJ4RGmu4wnQA.png" /><figcaption>Figure 58 — Architectural choices on where to involve human decision making in an entire system</figcaption></figure><p>Architecture is supposed to be the expression of our values and it is unfortunate that most architects never ask, let alone answer, the most important architectural questions of the day. There are a number of key roles that architects can and should be playing:</p><ol><li>Deciding where we value humans in the decision making process.</li><li>Determining the questions that need to be asked.</li><li>Understanding the existing system.</li><li>Being the arbiter of conflict between different decision makers.</li></ol><h3>Myth 6: Dealing with legacy is hard</h3><p>To explain this myth, let us start with a real company. Lifeware offers software as a service systems that manage the core data and automate the core workflows for insurance companies. The first step when Lifeware works with a new insurance company is to migrate their legacy system to the Lifeware infrastructure. To do this, they use a streamlined process that has provided a 100% success rate for the migration of over 20 insurance companies over the last two decades. Furthermore, once migrated, Lifeware evolves these systems faster and with a fraction of effort compared to the teams that worked on the systems they displaced.</p><p>Contrast these results with the typical industry reality. For example, according to the Advanced 2020 Mainframe Modernization Business Barometer, 74% of organizations have failed to complete their migration projects. That gives an industry typical of 26% success rate. Lifeware is an extraordinary outlier with a 100% success rate over 20 examples. On probability alone, the likelihood of Lifeware’s success being a random effect is about 1 in 500 billion. So, either Lifeware is extraordinarily lucky or they are doing something right.</p><p>They achieve this exceptional success because they have invested in software engineering as a business capability for three decades. They spot and adopt new fundamental engineering practices early. So much so that they were a flagship case study in the book which first introduced the ideas of test driven development. Lifeware had the largest test suite in the world at the time (4K tests in 2002). Currently, their test suite holds 160K tests for a system built with 35M lines of code. While the amount of tests grew non linearly over the past decades, the amount of time to run them is still measured in minutes. Today, every developer can transparently and directly run them on AWS clusters containing thousands of processors.</p><p>They achieved this feat over time by investing considerably in their development environment. They have created a variety of specific tools, including for technical reporting of migrations status, for overviewing their integration pipeline or for contextual debugging. More recently, they took a further step and adopted Moldable Development which includes the practice of building small contextual tools. They have already accumulated more than 3k contextual micro tools to guide their workflows, with over 1k being constructed only over the past four months. These tools complement their functional tests and accelerate their work. As a result, Lifeware can already attack larger migrations than before which directly and positively affects their business.</p><p>What is more difficult to explain is the level of integration that they achieved throughout the company: whether they investigate a system change together with the business, whether they script a custom code transformation, or whether they investigate the performance of an AWS cluster run, they never leave their environment. Rather than splitting their work across tool boundaries, they make tools come to their environment. The result is a truly integrated development experience consisting of thousands of contextual tools.</p><p>So, it seems that dealing with legacy is only hard when you don’t invest in engineering practices. There is no obvious reason why other companies can’t be sharing the same rates of success.</p><p>This focus on engineering is somewhat counter to today’s AI mantra, which gives us an interesting experiment. If investment in engineering practices and system comprehension are the primary drivers of success, then you would expect that investment and use of AI in development without a focus on engineering practices would lead to anomalies such as people believing that performance has improved whilst instability in delivery has increased.</p><p>This is what the DORA 2025 State of AI-assisted Software Development Report seems to have stumbled upon (pages 38, 41): high degrees of adoption and perception that performance had improved combined with increasing instability in delivery. Of course, perception is hardly a good yardstick for measurement.</p><p>Fortunately, we have a randomized controlled trial from METR that looked at how AI tools affected the productivity of experienced open source developers. What they found was that while developers expected and perceived an increased productivity, the use of such tools actually slowed development by 19%.</p><p>So, we seem to be on a sticky wicket with high adoption, perceptions of improvement and associated marketing claims against quantitative slowdown and increasing instability. How this gets resolved in the future is unclear as the practices needed for development with AI are still slowly emerging and will take many more years to mature. All we can say for now is that a focus on engineering practice is the better bet since engineering isn’t going away anytime soon.</p><h3>Myth 7: Non-technical people can’t understand code</h3><p>In the early 1970s, computers started to offer interfaces made of screens and keyboards. Whilst this was a considerable improvement on what existed before (printouts, punchcards, pluggable cables), there was no graphical interface, only text based screens and command line instructions. Such limited interaction abilities meant that the audience became those educated on the corpus of these instructions i.e. “technical” people.</p><p>At the same time, a different paradigm appeared at Xerox Parc known as the Smalltalk system with a bitmapped display, radical graphical interface including icons &amp; menus, application windows, keyboard and mouse. In this world, even children could understand and manipulate the system.</p><p>From technical experts in one world to children in another. Both were using similar underlying “computers”. Why such a huge difference?</p><p>It is the interface that determines the cognitive and practical barrier to entry, which in turn determines who can realistically use, manipulate and understand the system. In essence, an interface is a translation of a computation in a way that a human can understand and interact with. Interfaces are fundamental because we cannot perceive anything inside the computer that is not tied to an interface. In short, if you change the interface, you change the <em>audience.</em></p><p>When we say “only technical people can truly understand how the code works”, what we are really admitting is that the interface limits the audience to technical people. It’s a design choice, not a law of nature. Whilst you can enable a wider audience to use and understand a system through interface design choices, a deeper understanding still requires that audience to understand its construction which is often equated with the ability to read the code.</p><p>However, in Cozy Corner from the previous chapter, we’ve seen an example of how presenting the inner workings of a system could empower non-technical people to understand and have a say in its evolution. Any part of a system can be presented through a tool in a way that an audience can comprehend without reading code. In fact, even technical people should not resort to reading code as the primary means to understand the system’s inner workings.</p><p>Understanding a system through a tool only requires the tool user to appreciate what it does and not necessarily its construction. A surveyor can use a theodolite to reason about a landscape without awareness of the intricacies of theodolite construction, such as the use of bronze bearings to create carefully controlled friction. That said, there are certainly advantages with understanding the construction, and that pathway should never be closed.</p><p>However, there is an assumption that a deeper understanding of the output of a tool requires a deeper understanding of the tool itself and this requires a technical person. Fortunately, this deeper understanding can be provided by another tool. Hence, the technical person might be the pathfinder but that doesn’t mean the non-technical person can’t follow. This is best shown with an example.</p><p>In a previous chapter, we used a treemap visualization showing the classes from Glamorous Toolkit grouped by packages. The visualization (repeated below) highlights in blue the classes that have at least one associated contextual tool.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DQOqfD7dgwC2TZd1u7MJtw.png" /><figcaption>Figure 59 Treemap visualizing the parts of Glamorous Toolkit that have at least one associated contextual tool</figcaption></figure><p>This visualization is a tool inside Glamorous Toolkit (GT) whose subject is GT itself. This is a tool within a tool. This idea can be taken even further and can be applied at any granularity level. Whilst the tool was built by a technical user, a non-technical user is perfectly able to use the tool to gain a deeper understanding of GT than most technical users have of their own traditional development environments.</p><p>So, what if we want to know an even more technical aspect? For example, how does the layout work? That sounds like something only a specialized technical person could understand. So, let us give that a go with the aid of a tool.</p><p>To do that, let us consider a bit of history. The layout’s implementation is based on an algorithm called the Squarified Treemap. The article that introduced it contains the pseudocode and the math to describe what has to be implemented. More interestingly, though, it also includes a visual depiction of the steps the algorithm takes as seen below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qw9iwMNWVhGMRta42KFpVQ.png" /><figcaption>Figure 60 A diagramatic description of a squarified treemap algorithm, taken from Squarified Treemaps, Bruls et al, 2000</figcaption></figure><p>The picture shows multiple steps of laying out a set of 7 nodes with different areas. The sizes are denoted by numbers inside the boxes (6,6,4,3,2,2,1). The challenge the algorithm addresses is to arrange these so that we get a nice proportion between the overall width and height.</p><p>In the first step, it arranges a node with the largest area, which is 6. Then another, which is also 6. And then the third one with an area of 4. Only at this step, a condition about the proportions of the width and the height is not met, so the third step is discarded, the algorithm moves back one step and tries a different path. In this path, the node with weight 4 is placed to the right. And so the algorithm continues, hitting constraints, falling back to previous steps and trying again until all nodes are filled in. A non-technical person can easily understand what the algorithm is doing in this visual representation but may struggle to understand the code itself which is over 760 lines long. The visual depiction allows us to form an intuitive mental model of how the placement of elements work.</p><p>It was this same picture that guided the implementation of the algorithm into Glamorous Toolkit (GT). And once the implementation existed, it also included the tool to produce the same visualization for any given treemap. The picture below depicts this. On the left we see a concrete treemap of seven nodes like in the paper (just less dense than the one used to visualize the components in GT) and on the right we have the steps that the algorithm followed to produce the treemap provide by the same tool that was used in its implementation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Zkf4iXEmfYG-jJ-mgelNmA.png" /><figcaption>Figure 61 Two views of the treemap algorithm: one showing the result, one showing the steps to obtain the result</figcaption></figure><p>One minor detail to note is that by making the programmatic visualization available, we quickly discovered that for these specific 7 nodes and areas, the algorithm took 11 steps. However, the manual visualization in the original paper uses only 10 steps. This prompted a review of our interpretation of their algorithm (the right hand side of the image) even though the overall functionality (the left hand side) was equivalent. The person who used the visualization to challenge the interpretation of the algorithm was not the developer who had implemented it. Even non technical people can participate in highly technical conversations with the right interfaces. For those who are curious, what was discovered was the manual visualization contains a flaw.</p><p>Currently, GT contains over 5,000 such tools doing a similar job and making seemingly complicated technical details accessible to various audiences. Contrary to popular belief, any aspect of a software system can be explained in a way that’s understandable to an audience that is interested to learn about it.</p><p>One final thing to note, it is the artificial barrier created between technical and non-technical people that has led us to create misleading terms in an attempt to find common ground. One of our favourite, and probably the most misleading is technical debt.</p><h3>Myth 8: Technical debt exists</h3><p>Technical debt is an overloaded term today. It is used as a placeholder for all sorts of conversations, especially at the boundaries between technical and business areas. We should break free of it.</p><p>When Ward Cunningham came up with the term in 1992, it was a beautiful metaphor. At that time, the business people and technologists were often communicating through large documents. With just two words “technical” and “debt”, Ward brought together two worlds that were foreign to each other and gave them a common language to describe a specific problem in a financial system. He wanted to say that the structure of the system no longer fitted the new understanding that they gained by building and running it, and therefore they should stop and restructure it to mirror this. Like paying out a debt.</p><p>Due to the communication void caused by the chasm between the technical and non-technical world, this metaphor acted like a spark that ignited new kinds of conversations. And like that, the metaphor of technical debt took on a life of its own with many meanings being conflated into it. Ward later clarified that he never intended it to mean anything else than the difference between the current structure of the system, and the structure that we now wish the system to be. He never intended it to mean a reckless pile up of technology, for example.</p><p>A metaphor can be useful but this one has run its course. It’s time to outgrow it.</p><p>Ward Cunningham took a complex, multi-dimensional problem and reduced it to a single scalar that business could grasp. That scalar did not need to be accurate; it only needed to improve the business’s understanding of the system. The problem is that systems are influenced along multiple dimensions including code, context, skills, and tools.</p><p>The code represents what the system does (function) and how it does it (structure). But that code exists within an environment, and is shaped by the skills and tools used to build, operate, and understand it. What we are really dealing with is a tensor of function, structure, context, skills, and tools, compressed into a single scalar called “technical debt”, a value that people then attempt to measure by examining structure alone.</p><p>Whilst function, structure, context, skills and tools are real and tangible, the scalar is imaginary. Its role was simply to help provide the business with “insight” because “non-technical people can’t understand code” (see myth 7). This scalar is however as damaging to understanding as that other horrendously simplified scalar known as GDP is. In that case, Simon Kuznets (the inventor of GDP), warned from the very beginning that it should not be used as a measure of national success or wellbeing which is of course what it has been used for. People like simple scalars, like KPIs, regardless of whether they are useful or downright harmful. They have the one property that makes it appealing for busy people … they are simple.</p><p>However, the scalar being a compression of these multiple facets has one uncomfortable property. Its “value” can change by simply changing one or more of the facets i.e. if I change the tools or change the context then I could potentially make a huge debt disappear as if by magic. It’s not however magic, it’s just that the scalar is not real, it’s imaginary, a compression of things that are real.</p><p>Consider the following thought experiment: If we could change the tools and skills so that we could understand and change our systems at will and at zero cost, would we still talk about technical debt? We think not. A couple of decades ago, changing the name of a function was a tedious action potentially involving breaking code and requiring manual changes in multiple places; today, the same action can be handled through an automatic refactoring at zero cost. Without such refactorings, having a function with the wrong name could be qualified and even quantified as technical debt. But with refactorings, qualifying the same situation as technical debt would be misleading at best.</p><p>A simple change of tools and skills has made the technical debt disappear. It’s the sort of financial engineering that accountants could only dream of, alas in their world debt is something very real.</p><p>You might say that this only works in narrow cases. But the bottom line is that we will only find these other cases if we accept that the possibility exists, so that’s where we should start from. The good news is that we do not have to talk in hypotheticals. Throughout this book we show multiple examples of how something that appears expensive becomes many times less by changing the skills and tools.</p><p>Legacy IT estates are commonly considered to be part of an organization’s “technical debt”, but in myth 6 you saw a case in which a large legacy system can be moved much faster than the competition. This shows that investing in engineering practices makes the technical debt disappear and can even turn it into a competitive advantage.</p><p>Along with being an imaginary compression, it also suffers from being framed as a negative metaphor. The best case scenario is to not have debt. Having this monopolize the conversation drives a behaviour of always trying to reduce whatever is associated with that number, including the idea of software engineering as a cost structure, or of outsourcing it to other companies. That might be the right approach but as we saw with the legacy example, so might investing in engineering practices.</p><p>Another side effect is joy. When systems become understandable and changeable, engineering becomes joyful. So, not only do you get to solve your most expensive problem, you get to make it fun in the process, too. Isn’t that worth breaking free of a 30-year old metaphor that is imaginary?</p><h3>What did we learn?</h3><p>Before we move on, let us pause to look on the mighty works of our industry’s myths, and despair.</p><p>“Software engineering is about building functionality” crumbled first because software engineering is not only about functionality but also structure. This then exposed the myth of “Refactoring is not a business problem” because the organization’s knowledge is encoded in that structure. At this point, the tower of “Software engineering is an engineering practice” leans over and collapses because it was stretching the truth to breaking point. Testing has evolved into an engineering discipline by building contextual tools at scale. Development should follow the same path.</p><p>Recently, we have been deafened by a thousand AI purists chanting that “LLMs will replace software engineers”, but LLMs do not remove the need for engineers, they amplify the value of the engineering path that creates better questions, better tools, and better feedback. This matters because system decisions are made in code and not in the specifications, diagrams or other faith based artefacts that made people worship at the altar of “architects make decisions”. This doesn’t mean that architects don’t matter. They do because they should be deciding where we value humans in the decision making process.</p><p>By focusing on these engineering practices we can finally solve “the legacy is hard” trap which is even more pernicious than the idea that “non-technical people cannot understand code”. We finish our journey through the lands of Ozymandius with a search for mythical beasts. Yes, we too have heard (and even used the idea) that “technical debt exists”, alas, whilst well meant it’s mostly imaginary and misleading.</p><p>In overcoming all these myths, LLMs can be an enabler, for example in the building of micro-tools, but they also pose an ever present danger by removing the conditions for comprehension.</p><p>Before we leave, it’s worth noting that there are many more myths we could have explored. This is not an exhaustive list and we both had to make compromises. Simon, for example, would happily spend several chapters on how LLMs are non kinetic forms of warfare and why most of today’s digital sovereignty discussion (with its focus on territorial location) misses the mark by a mile. Tudor would have expanded on how the inability to read systems leads to a world of functional illiteracy that provides fertile ground for myths to flourish. However, for brevity, we made those compromises and chose only eight. We then traced their existence to our missing two wolves.</p><h3>Homework</h3><p>As a team, pick a legacy system that is often described as “technical debt”.</p><ol><li>Determine what business value would be enabled if you could change it at will?</li><li>Pick three manual diagrams about that system. Do you believe these represent the system?</li><li>Write down the words: context, skills, tools. What change in each would diminish the apparent technical debt?</li><li>[For technical users] : Redo the experiment from myth 4. If you are happy sharing the information, use Claude Code (or an LLM/Agent of your choosing) to create a visualization of the module dependencies (such as npm). By changing only the beginning of the prompt you created, ask the LLM to create a tool to generate the visualization. Compare the two visualizations.</li><li>Write one sentence on where you want human judgement to remain non-negotiable in that system (and why).</li></ol><p>—</p><h3>Rewilding Software Engineering</h3><p><a href="https://medium.com/feenk/rewilding-software-engineering-900ca95ebc8c">Chapter 1: Introduction</a><br><a href="https://medium.com/feenk/rewilding-software-engineering-083b86c81c43">Chapter 2: How we make decisions</a><br><a href="https://medium.com/feenk/rewilding-software-engineering-f758ec97ddb2">Chapter 3: Questions and answers</a><br><a href="https://medium.com/feenk/rewilding-software-engineering-a3601a066e50">Chapter 4: Flexing those thinking muscles</a><br><a href="https://medium.com/feenk/chapter-5-different-folks-for-different-strokes-70d24a750dff">Chapter 5: Different folks for different strokes</a><br>Chapter 6: Myths we tell ourselves</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ca3ad1e612d8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/feenk/rewilding-software-engineering-ca3ad1e612d8">Rewilding Software Engineering</a> was originally published in <a href="https://medium.com/feenk">feenk</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[LLMs are coherence engines, not truth engines]]></title>
            <link>https://medium.com/mapai/llms-are-coherence-engines-not-truth-engines-903f5209646f?source=rss-280dd9543ba9------2</link>
            <guid isPermaLink="false">https://medium.com/p/903f5209646f</guid>
            <dc:creator><![CDATA[swardley]]></dc:creator>
            <pubDate>Thu, 08 Jan 2026 14:41:18 GMT</pubDate>
            <atom:updated>2026-01-08T23:29:50.869Z</atom:updated>
            <content:encoded><![CDATA[<p>Large Language Models (LLMs) such as GPT are best understood as coherence engines. They are trained to produce outputs that are statistically and rhetorically coherent given an input. Their function is not truth, but the generation of sequences of tokens that resemble what humans would reasonably say next. This includes the use of tools.</p><p>As a result, an LLM can generate arguments that are internally consistent, convincing, and persuasive, yet entirely false. The model has no access to the world, no sensory grounding, no lived experience, and no intrinsic way to check correspondence between its outputs and reality.</p><p><em>LLMs ≠ truth</em></p><h4>Humans aren’t truth engines either</h4><p>The uncomfortable part is that this critique applies almost as well to humans. Human cognition is also coherence driven. We construct narratives, causal explanations, identities, and moral frameworks that hang together, rather than ones that are objectively correct.</p><p>We also continuously prioritise narrative consistency, social acceptability and reinforce biases based on beliefs. Most of what we call “belief” is post-hoc rationalisation of events combined with habit and social signalling. Whether we like it or not, we are story-making machines operating under evolutionary constraints.</p><p><em>humans ≠ truth.</em></p><h4>Truth as grounding, not absolute truth</h4><p>We don’t have access to absolute truth. The best we have is grounded truth, which emerges from shared experience, empirical interaction with the world, and feedback loops between belief and consequence. Even in science, we oscillate between seeking coherent models (the path of coherence) to explain an observation, and then attempting to falsify the model we have just created (the path of truth) through observation. Since there is no absolute truth, we rely on falsification through grounded truth, in this case the measurement of interactions with the world.</p><p>No one in science creates a coherent model and has the rest of the community announce “that must be right” and stops all questioning in that field. Instead science works because it builds institutional scaffolding that forces grounding through measurement, replication, falsification, and peer review. Without grounding, both humans and LLMs drift into elegant nonsense.</p><p><em>ground truth ≠ absolute truth.</em></p><h4>A key difference between Humans and LLMs</h4><p>Humans can ground, LLMs cannot (yet). To put it bluntly, humans can test beliefs against reality, suffer consequences for being wrong, and update beliefs through embodied experience.</p><p>LLMs cannot do any of these things autonomously. Their grounding is always borrowed from human produced data and human validated feedback. Even when plugged into tools or sensors, that grounding remains mediated. So while humans and LLMs both generate coherence, only humans have the capacity for grounding through lived interaction.</p><p><em>coherence ≠ coherence + ground truth.</em></p><h4>A key danger</h4><p>The risk with LLMs is not that they lie, but that they speak with fluent confidence in domains where humans already confuse coherence with truth. When an LLM produces a well structured argument, people instinctively grant it authority they would not give to a rambling human. Why? Because it is a computer, and we are so used to deterministic systems getting things right (a common belief that most humans share) that many assume nondeterministic systems built with computers (which an LLM is) must also be right. They are not. LLMs are coherence engines, not truth engines.</p><p><em>coherence ≠ truth.</em></p><h4>But the horse has bolted</h4><p>As I explained before, <a href="https://medium.com/mapai/ai-and-the-new-theocracies-9b573eb9ab1b">“If you can gain control over language, medium, and tools then you can change a person’s reasoning of the world around them</a>”. Without the armour of critical thinking, then I suspect that in the West, these LLMs will become the new “grounded” truth for many, if not most, regardless of whose beliefs they maybe skewed by — think Grok and Elon Musk.</p><p>We’ve already seen what this looks like with X and Truth Social which for many have become the “grounded” truth for news, rather than traditional media which is often derided as fake. The only difference is scale. It won’t just be news but everything. That’s the world you have to be thinking about and adapting to.</p><p>In this new world …<br><em>truth = coherence + creators ground truth<br></em>… and that should terrify you.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=903f5209646f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/mapai/llms-are-coherence-engines-not-truth-engines-903f5209646f">LLMs are coherence engines, not truth engines</a> was originally published in <a href="https://medium.com/mapai">MapAI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[2026, Brexit, Sovereignty and all that.]]></title>
            <link>https://medium.com/mapculture/2026-brexit-sovereignty-and-all-that-4f61409bdf88?source=rss-280dd9543ba9------2</link>
            <guid isPermaLink="false">https://medium.com/p/4f61409bdf88</guid>
            <dc:creator><![CDATA[swardley]]></dc:creator>
            <pubDate>Mon, 05 Jan 2026 00:37:35 GMT</pubDate>
            <atom:updated>2026-01-08T14:34:34.292Z</atom:updated>
            <content:encoded><![CDATA[<h4>Less identity, more sovereignty please.</h4><p>I am pro Brexit for a simple reason. Sovereignty matters.</p><p>Not the theatrical version of sovereignty, and not the fantasy version where choices come without consequences. The practical, legal and operational kind. Who decides? Who has authority? Who can change direction when circumstances change?</p><p>The European Union is not just a market but a political project whose institutional design embeds a direction of travel towards deeper integration, even as that trajectory remains contested within it. Ever closer union is not a side effect, it is the structural tendency embedded in the treaties. Membership means shared rule making and legal supremacy whether you agree with the direction or not. Leaving the EU treaties mattered because it restored something fundamental. Parliamentary sovereignty as a matter of law with domestic courts as the final authority. This means the ability to align when it makes sense and diverge when it does not. The freedom to choose, and to live with the consequences of that choice. That is what sovereignty actually looks like.</p><p>This is why EEA via EFTA was, for me, the acceptable end state. Not a trick, not a staging post and not a fudge. It was the better compromise because under that model the UK would be outside the EU treaties and institutions. EU law would not have supremacy and nothing would apply automatically. Every rule would require domestic implementation with alignment happening because we chose it. And when we chose not to align, the consequences would be economic rather than constitutional. Loss of access, not loss of authority. That distinction matters.</p><p>This is not a claim that EEA/EFTA (known commonly as the Norway model) abolishes hierarchy. It does not. It replaces constitutional subordination with economic constraint. The difference is that constitutional binds regardless of consent, whilst economic preserves the ability to refuse and accept the cost. This matters because sovereignty is not freedom from constraint, it is the ability to choose your constraints knowingly.</p><p>There is another position I hold almost as strongly as sovereignty, and it sits alongside EEA/EFTA without contradiction. I am in favour of free movement of people. The UK has a long history of immigration and mobility. We are a trading and maritime nation that has been shaped by successive waves of people arriving, settling, contributing and becoming part of the whole. Movement is not an aberration in our history, it is the norm.</p><p>Labour mobility brings skills, ideas, adaptability and resilience. It strengthens systems when handled through institutions rather than fear. Treating people as something to be controlled rather than participants in a shared society is insecurity pretending to be policy. I do have a concern over freedom but it has never been about people moving. It has always been about capital moving without counterbalance.</p><p>Capital is not neutral. Unconstrained capital accumulates power, distorts incentives, inflates assets and captures regulation. In the UK this has been visible in housing, where capital mobility and asset protection have driven prices far beyond wages, turning shelter into speculative instruments at the same time that labour security has been hollowed out. This is not theory, it is the lived outcome of decades of neoliberal policy in which markets discipline governments rather than the other way around. So yes, I am sceptical of free movement of capital. Not because I want isolation, but because capital without constraint becomes political power without accountability.</p><p>But here is the uncomfortable reality. If you want a European market, you get the European bundle. Labour mobility and capital mobility come together because the system is designed that way. You do not get to surgically remove one without destabilising the whole. Labour mobility without capital mobility leads to exploitation. Capital mobility without labour mobility leads to rent extraction. The four freedoms (goods, services, capital and people) are bundled because the system itself is bundled.</p><p>However, reality is always why I am willing to compromise. EEA/EFTA did not lie about this. It said this is the structure, these are the trade-offs, choose. I might not like capital mobility, but pretending you could retain market access while discarding it was fantasy.</p><p>So, why did EEA/EFTA fail as an option?</p><p>Opposition from hard Brexit advocates was inevitable. That was never surprising. For them Brexit became about visible rupture with sovereignty redefined as divergence rather than choice … “we’re not them” rather than “what is best for us”. Any ongoing alignment was framed as betrayal regardless of legal reality. EEA/EFTA offered sovereignty without theatre but that was always going to be rejected by those who needed Brexit to look like separation rather than governance.</p><p>What was more striking was the intensity of opposition from Remain. Not disagreement, but actual opposition. That was a real shock.</p><p>I would have thought that EEA/EFTA passed every test that many Remainers claimed to care about. It preserved cooperation, it reduced economic shock, it maintained regulatory alignment and even avoided a race to the bottom. It kept the UK closely integrated with Europe whilst preserving free movement of people, which many said was a red line. And yet it was treated not as an acceptable settlement, but as something to be actively resisted.</p><p>The reason was not technical as the model works. The reason seemed more political. In practice, EEA/EFTA reframed Brexit from a moral failure into a settlement, a shift many Remainers found politically unacceptable. A Brexit that functioned quietly undermined the argument that leaving was inherently reckless whereas a Brexit that failed loudly kept the argument alive.</p><p>So EEA/EFTA ended up in a political dead zone. Too much alignment for those who wanted rupture. Too much stability for those who wanted reversal. If you look at the indicative results in the House of Commons, then EEA/EFTA got<a href="https://www.theguardian.com/uk-news/ng-interactive/2019/mar/27/how-did-your-mp-vote-in-the-indicative-votes"> a mighty 64 votes for it (the vast majority of which were Conservative) and 377 against</a>. It ranked as the least favoured option, and you don’t get much more dead than that. For those of us on the brexit side who supported EEA/EFTA, it was the nail in the coffin for what many of us considered to be the better compromise.</p><p>Of course, Labour’s position had became critically important, and Labour had been deeply confused. Corbyn (leader at that time) was “Wary of single market membership”, McDonnell (shadow chancellor) “Did not definitely rule out staying in the single market, if it could be reformed” and Starmer (shadow Brexit secretary) stated that “Labour’s policy is that Britain should remain in the single market and the customs union for a transitional period of two to four years”. Three people, three different positions and one party.</p><p>However, this should not have been surprising. Labour has never been instinctively pro European integration. As Hugh Gaitskell warned in the early 1960s, joining the European project risked subsuming democratic control within a larger political structure. Tony Benn later argued that European institutions could be used to lock in market discipline beyond the reach of domestic voters. These tensions were never resolved within the party, they were merely parked.</p><p>By the time of Brexit, that unresolved history collided with a coalition built on ideas of liberal internationalism. When the space to compromise collapsed, Labour was forced to decide what Brexit actually was. A structural question about governance and power, or an identity question about belonging and values? This shows up most clearly in the difference between Corbyn and Starmer.</p><p>Corbyn treated Brexit as a structural problem. He understood that the Single Market embeds an economic order that privileges capital mobility, competition law and limits on state aid which hence constrain democratic intervention. His objection was not to Europe as such, but to where power sat. His instincts were right, they often are. The difficulty was that he never landed on a viable European architecture that could constrain capital while retaining access. This was a common theme with Corbyn, a history of exceptional instincts and being on the right side combined with an inability to deliver.</p><p>On the other hand, Starmer appears to treat Brexit as an identity problem to be managed. This is not because he is blind to the structural issues, but because he is operating in an environment shaped by aggressive identity politics on the right. Farage (and more lately Reform UK) have framed Brexit as a permanent cultural struggle, where any accommodation with Europe is betrayal and any movement on migration is surrender. Farage has always cast the identity card, summoning the spectre of nationalism. In such an environment, free movement of people becomes the most potent political weapon, regardless of its economic or historical reality.</p><p>Seen through that lens, Starmer’s red lines are understandable. By ruling out free movement of people while quietly accepting capital mobility and regulatory alignment, he attempts to neutralise the identity attack surface while stabilising the economy. It is a defensive strategy (a sort of Norway-lite) that is designed to survive a political landscape where nuance is punished.</p><p>But understandable is not the same as correct.</p><p>What results is still a distributional settlement. Capital remains fluid with finance protected and asset values defended. But people are managed. It’s the market that benefits and not society. The costs of this adjustment falls on people and communities, while the benefits accrue upwards. EEA/EFTA did not pretend to magically solve this tension but instead exposed it. Under EEA/EFTA, everyone compromised. People moved. Capital moved. Sovereignty was explicit but there was a price. The choice to reject alignment was real.</p><p>Some argued (and still do) that EEA/EFTA was intellectually honest but politically hollow. That it clarified trade-offs, but at the cost of permanent marginalisation that offered neither the agency of membership nor the rupture demanded by identity politics. Whilst I understand such objections they rest on a different definition of agency to mine.</p><p>Agency is not a claim that sovereignty means you can always say no without cost. That has never been true. Sovereignty is not the absence of consequence but instead the ability to say no at all. The moment refusal disappears, choice becomes procedural rather than real. Being able to shape a decision you cannot refuse is not the same as being able to refuse a decision you did not shape. Influence without refusal is not power, it is conditional participation.</p><p>What is often described as effective power is, in practice, managed dependence where outcomes are negotiated, but consent is assumed. The disagreement on agency is about whether consent survives once refusal is removed from the system. I would argue that sovereignty grows not from the power to say “yes” but the power to say “no”. Remove that and agency becomes contingent rather than sovereign, reduced to influence exercised within constraints you no longer have the right to refuse.</p><p>However, a common Remain position tended to privilege the “voice inside the system” argument. The EEA/EFTA position does the opposite and privileges exit from hierarchy and the right to say no, even when saying no is costly. From the Remain perspective, EEA/EFTA understandably looks like marginalisation and I do understand this. But from a Brexit perspective, it looks like bounded autonomy exercised honestly. These are not competing empirical claims but instead competing theories of agency in a world where absolute control does not exist.</p><p>Alas, the idea of EEA/EFTA failed. It did not do so because it misunderstood the trade-offs, it failed because it occupied a space that neither sides’ preferred definition of agency could comfortably accept. One side wanted influence without exit. The other wanted exit without constraint. EEA/EFTA insisted on choice with consequence. That was not politically hollow but it was politically inconvenient.</p><p>For these reasons, I still believe EEA via EFTA was the more honest form of Brexit. Not perfect. Not pure. But sovereign in the only sense that mattered, and honest about what it asked of both people and markets. I do wish that we could explore this option once more. However, I am not naïve about the political reality.</p><p>Brexit is no longer being treated as a constitutional design problem or an economic governance question. It is being managed as an identity settlement. In that mode of politics, symbols matter more than structures and optics matter more than outcomes. Any settlement that works quietly reduces conflict, and conflict is what sustains identity politics. In that respect, I am somewhat encouraged by Starmer’s instinct to work quietly in the national interest rather than rehearse Brexit as a permanent culture war, even if I disagree with where he has chosen to draw his red lines in terms of freedom of movement.</p><p>However, this conflict over identity is why the space for honest compromise has become very narrow. Not because the compromise is flawed, but because it cannot be defended without breaking the rules of the game. It requires politicians to say this works, this has costs, and we accept them. In an identity driven settlement, that is read as weakness or betrayal. Expect endless GB News articles on how Starmer is selling out to Europe when he is not. But these days it seems like truthfulness is something that belongs to a bygone era. We even have <a href="https://www.theguardian.com/society/2026/jan/04/is-the-uk-really-heading-towards-civil-war">neo nazi fantasies of UK entering civil war </a>being brought in general discourse as though that was something normal. It’s not.</p><p>Given this, am I still pro Brexit? Yes, for the same simple reason that I have always supported it. Sovereignty matters. In the UK, that sovereignty is enshrined in our <a href="https://blog.gardeviance.org/2016/04/on-europe.html">political process of democracy</a> and that’s my red line.</p><p>As for Starmer, he continues to impress. I preferred the instincts of Corbyn but as much as I would like to think that there could have been a different path, Corbyn wasn’t able to deliver. Starmer has the quiet fortitude through which he might. For labour, I would suggest not trying to re-open questions of customs union and allow Starmer to do his job.</p><p>As for Reform UK, they continue to bang the identity drum as loudly as possible when it comes to people. They point the finger at “others” even though its capital that accumulates power, captures regulation and deprives people of services. It’s true that Reform UK’s populism targets visible elites and cultural symbols but they consistently avoid sustained critique of capital power or asset ownership. I often wonder whether that is down to its funding base, drawn largely from wealthy individuals, which sits uneasily alongside this anti “elite” rhetoric. In practice, its economic platform reproduces familiar neoliberal patterns of selective spending, pressure for cuts, and political blame directed toward people rather than capital structures.</p><p>Early experience in Kent suggests this translates into cultural signalling (such as<a href="https://democracy.kent.gov.uk/mgConvert2PDF.aspx?ID=130849"> council decisions not to fly the pride flag in the future</a>) rather than material improvement, a rather authoritarian stance of <a href="https://www.itv.com/news/meridian/2025-11-17/reform-uk-concludes-video-leak-investigation">“f****** suck it up” </a>to council meetings, the importation of a <a href="https://www.localgovernmentlawyer.co.uk/employment/395-employment-news/61125-reform-uk-says-officers-who-obstruct-internal-review-team-sent-into-county-council-will-be-guilty-of-gross-misconduct">Musk style DOGE effort</a> (and hasn’t that gone so well) and what Bloomberg called <a href="https://www.bloomberg.com/opinion/articles/2025-11-19/reform-uk-nigel-farage-kent-stronghold-consumed-by-turmoil-and-farce">“a total circus”</a>. We are not the better for it. However, I am encouraged that support for these <a href="https://www.thelondoneconomic.com/politics/reform-support-plummets-in-latest-polling-as-labour-gain-401686/">“ideas”</a> are finally showing signs of weakening.</p><p>As we enter 2026, a decade after that referendum, I would hope that we can rediscover a politics grounded less in identity and more in questions of sovereignty.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4f61409bdf88" width="1" height="1" alt=""><hr><p><a href="https://medium.com/mapculture/2026-brexit-sovereignty-and-all-that-4f61409bdf88">2026, Brexit, Sovereignty and all that.</a> was originally published in <a href="https://medium.com/mapculture">MapCulture</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Rewilding software engineering]]></title>
            <link>https://medium.com/feenk/chapter-5-different-folks-for-different-strokes-70d24a750dff?source=rss-280dd9543ba9------2</link>
            <guid isPermaLink="false">https://medium.com/p/70d24a750dff</guid>
            <category><![CDATA[rewilding]]></category>
            <category><![CDATA[moldable-development]]></category>
            <category><![CDATA[wardley-maps]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[swardley]]></dc:creator>
            <pubDate>Thu, 22 May 2025 19:23:01 GMT</pubDate>
            <atom:updated>2026-01-23T12:28:00.984Z</atom:updated>
            <content:encoded><![CDATA[<h4>Chapter 5: Different folks for different strokes</h4><p><em>By Tudor Girba and Simon Wardley</em></p><h3>An apology</h3><p>This book is about software engineering, but we start this chapter by talking to the business. We know that you’ve been wanting to fire those pedantic, inflexible, costly and annoying software engineers for ages. AI appears to be so damn helpful and so much more of a partner that you think that now is the right time to part ways. But give them a second chance, you will need them, software engineers can change and so can you.</p><p>We understand that in business you don’t care about the decisions made in code but you do care about how it works. Software engineers also care about how the systems work, but they care more about the decisions made in code. We can bridge this gap and bring you both together. We’ve done it before. We need to start by sitting down for a chat, somewhere comfortable, somewhere cozy.</p><h3>The Cozy Corner</h3><p>Until now we talked more about technical problems, like finding unnecessary data in a pipeline, debugging a stuck cursor, or explaining an algorithm. Those are problems which concern software engineers, and are far from your business language. So, let us talk about the restaurant business for a change.</p><p>During 2017, Tudor (as Simon was off elsewhere) had the privilege of observing how restaurants function and aim to produce value. Our observations were qualitative rather than quantitative and stem from personal experience mostly coming from eating at restaurants throughout the world. We have seen polite waiters, rushing bill boys, and bossy Oberkellners. We have seen food being served impeccably, and we have experienced the frustration of waiting for the bill.</p><p>From this journey, we came to believe that the core of the restaurant business was not yet digitized by anyone. There exists automation in different parts of the domain, but not at its core and not in general. But, what is that core?</p><p>From a consumer point of view, the value of a venue, being small or large, comes from two components: from the products it sells and from the experience it offers. From the business viewpoint, the value also depends on the costs with which the services are provided. To be complete, any optimization through automation must focus on all these dimensions in a uniform way.</p><p>A quick scan of the trade magazines shows there isn’t a shortage of systems trying to automate the restaurant business. Unfortunately, whilst they address some restaurant problems (the ones they were designed for), the restaurant business is highly variable. Hence, most of these systems either fail or try to force the restaurants to change their practice. There is no standard system that fits every restaurant. That was the challenge to address.</p><p>Our first clue was in the inconsistency of service found in busy restaurants when waiters become overloaded with demands. The problem to solve at the core of a restaurant seemed to be communication. It’s why a waiter sometimes comes over and asks whether you’ve got your order.</p><p>So how do you fix this? We need to start thinking about how messages are sent throughout the restaurant. Take Cozy Corner, a small restaurant with two tables served by a waiter and a kitchen with the cook. At its simplest we want the waiter to communicate with the chef, which they could do by talking to them. However, what happens if there is more than one waiter, maybe there’s two or three or six? Do we need a queue of waiters lining up patiently for the chef? And what happens when the chef needs to tell the waiter the food is finished? What if there is more than one chef? Maybe there are chefs that specialise in different dishes? Pretty quickly communication becomes messy.</p><p>We often try to solve this problem by introducing elements of queuing with paper notes. The famous carousel or ticket wheel. However, this is a carousel for creating food, but what about delivery and paying? The ticket wheel itself can often become a bottleneck in communication. So, the solution is to turn the ticket wheel into a digital solution and we’re done? Easy!</p><p>Think again, we’re back to the problem we started with — yes, you can automate some parts but the restaurant business is highly variable and contextual; so, the solution in one place doesn’t work in another. Since we’re talking about communication, the alternative is to build a language that enables an owner to describe their restaurant. That sounds a bit crazy but let us show you how in figure 34.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*p88BlMW7k95UnTgB" /><figcaption>Figure 34 — Communication flow in the Cozy restaurant</figcaption></figure><p>The guests have a wish — from I’d like to order drinks, can I buy a macaroni cheese or please can I settle my bill. The waiter transforms that wish into a message which is passed to the table. The table passes the message to the room. The room (there could be many) annotates this and passes it onto the business. The business interprets the message and potentially creates another one that is addressed to the kitchen. The chef gets an item on the to-do list.</p><p>The chef now cooks our sumptuous meal. When ready, they pass a message to the kitchen, the kitchen tells the business, the business tells the right room, the room tells the table and the table tells the waiter to deliver the food.</p><p>Through this mechanism the waiter and the cook can communicate without knowing of each other’s existence, and it can scale to arbitrary sizes and restaurant-specific processes i.e. we can describe any restaurant with this language. That’s the good news, the bad news is it’s just a theory. We would actually need to build a language on how to pass these messages. This is exactly what we did in 2017.</p><p>The idea is far from trivial. We sketched pictures like the one above to reason about our idea for an algorithm of propagating messages. These pictures offer a common ground for both technical and non-technical people to discuss the space. One thing which we should note here, because we return to it later, is the difference between where the work is done and where we learn, express and discuss ideas.</p><p>This sounds a bit counterintuitive but it’s one of those hidden in plain sight engineering practices. Walk into any engineering department and you’ll find the same problems being discussed in two different mediums. In software engineering those are the screen (where coding is done) and the whiteboard (where ideas are expressed). It’s the same with financial engineering groups — plenty of spreadsheets (where the work is done) and whiteboards (where ideas are expressed).</p><p>Domain Driven Design or DDD proposes the use of a ubiquitous language to bridge these two mediums. Here, the “domain” is the real-world problem that the software is trying to solve. If you’re building software for a bakery, the domain is baking and running a bakery. If you’re working on an app for doctors, the domain is medicine and healthcare. In our case, it’s the restaurant.</p><p>Instead of starting with tech stuff, we talk to the people who actually do the work — the bakers, the doctors, the waiters — using diagrams to understand how they think, how they talk, and what they actually do. We don’t try to solve the problem but instead we model the space like a baker would with orders, ingredients, ovens and timers and then use this to design our language. This is how DDD is practiced today — taking the hand drawn diagrams and transforming them into readable code. Perhaps like this one:</p><pre>//Construct the restaurant and the staff<br>cozyCorner := Venue new name: &#39;Cozy Corner&#39;.<br>kitchen := Area new name: &#39;Kitchen&#39;; parentArea: cozyCorner.<br>room := Area new name: &#39;Room&#39;; parentArea: cozyCorner.<br>table1 := Area new name: &#39;Table 1&#39;; parentArea: room.<br>table2 := Area new name: &#39;Table 2&#39;; parentArea: room.<br>johnWaiter := Contributor new <br>                  name: &#39;John Waiter&#39;; <br>                  addArea: table1; addArea: table2.<br>jeffCook := Contributor new name: &#39;Jeff Cook&#39;; addArea: kitchen.<br><br>//Setup logic for the parts (not shown here)<br>…<br><br>//Order some food<br>sirloinSteak := Consumable new <br>                   name: &#39;Sirloin steak&#39;;<br>                   price: ((30 EUR asPrice discountedBy: 10 percent) <br>                           discountedBy: 5 EUR).<br>sirloinSteakMenuItem := MenuItem new consumable: sirloinSteak.<br>order := Order new <br>            addOrderItem: (OrderItem new menuItem: sirloinSteakMenuItem).<br>orderMessage := OrderMessage new order: order.<br>johnWaiter send: orderMessage to: table1.</pre><p>Please take a moment to read the code even if you are not too familiar with programming. It’s in enough English that you should be able to get a gist of what is happening. Indeed, if you read the code above and squint hard enough, you can imagine the picture from the whiteboard.</p><p>In our case, this description is written in an internal domain specific language which is just a fancy way of saying an object specific model designed for that domain. It’s worth understanding that traditionally, variation in systems is often supported with configurations, each variant being treated as though it was an independent problem. This sort of solution becomes harder over time because the configuration combinations explode. The alternative is to find a language in which a set of variations can be expressed with simpler mechanics. In our case, this internal domain specific language not only describes the object model and variations but goes deeper into describing the logical setup of operators.</p><p>We have to go a little deeper here but bear with us. Let us look again at the code above. The code starts by creating and linking a few entities like the cozyCorner or jeffCook. These are of the same kind but with slight variations. We called them actors. Actors know how to send and react to messages. How they do those operations is defined in the logic part that we did not show above. So, let’s remedy that. The cozyCorner defines how it handles the OrderMessage something like this:</p><pre>//Setup logic for the parts<br>cozyCorner<br>  when: [ :message | message is: OrderMessage ]<br>  act: [ :message :result |<br>    message handlingActor addOrder: message order.<br>    message orderItems do: [ :item | <br>      result send: (ProduceMessage new orderItem: item) ] ].<br>...</pre><p>Ok, we know that’s too technical. The gist of it is that actors can define logic based on a condition and associated action, and the result of an action can be one or more messages being sent. This then provides the basis for a language with which we can program complicated flows. It’s fine to not understand the code in all its details, but this should not mean that you are excluded from the discussion. What we need is a visualization that everyone can relate to, a true ubiquitous language. Hence, the importance of our whiteboard.</p><p>We now have a logical diagram and we have code that implements the logic. However, if these visualizations remain only on the whiteboard, drawing them every time we want to test new scenarios or updating them as we gain new insights into how the model should behave then this quickly becomes a highly tedious task. What’s worse is that a manually created picture represents a belief about an existing system and not the actual system. This is where we depart from DDD. We get our system to create our whiteboards for us.</p><p>Figure 35 shows a logical diagram produced automatically from the logic in the system. It captures the propagation of the order (red), the produce (blue) and the deliver (cyan) messages through the venue. How do we do this? We simply build the tool to automatically generate it out of the implemented logic. With a tool like this, the cost of recreating the whiteboard with different variations of venues now becomes close to zero.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*PxoEh6rkkHAecEh0" /><figcaption>Figure 35 — Visualizing the flow started by placing of an order</figcaption></figure><p>Let’s take a moment just to think about this. Our normal way of operating is to update the whiteboard and then produce the code. However, because we now have a tool which automatically creates the whiteboard from the code, we can simply modify the code to see what it looks like and discuss the visualization with the group. This feels like it should be normal practice in any business process. This doesn’t seem to be a big ask. If one cog moves, the rest shifts too. Our visualizations should be part of the machinery — not just decorations taped to the wall or scribbled on a whiteboard.</p><h3>The importance of visualization</h3><p>As soon as we presented the generated diagram to the business, they immediately started to express ideas and asked for variations. Only this time, we did not start from an empty whiteboard but from a system generated reflection of itself. For example, an interesting variation is to allow for a guest (called Alice) that comes into the restaurant with a phone. Why shouldn’t Alice simply connect to the table and order directly through the digital interface without involving the waiter?</p><p>The business people sketched the idea manually on the generated diagram (see the left hand side of figure 36). The code was then changed and a new visualization automatically created (see the right hand side of figure 36) to ensure it matched. The entire development process was a few minutes and most of the development energy was spent on sketching and discussing ideas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*XiBXZDs4_WzH6-w-" /><figcaption>Figure 36 — From a business idea to a running system</figcaption></figure><p>We can hear you saying “Ah, but you still have to turn that visualization into a running system”. No, the visualization is of the running system — that’s the point. This isn’t an exercise in how to more efficiently create whiteboard diagrams. The diagram is the running system, it’s a self representation. Once the change was in place, we could see that indeed, without changing anything in Cozy Corner, Alice could place the order and the cook was notified, when the cook said it’s ready, the waiter was notified.</p><p>As soon as the business group saw the result, that started the next conversation, the next set of ideas to be expressed: Should the waiter or the guest be notified? Well, it depends on the flow of the restaurant. And so we went on to discover an adjacent unexplored area. And so on.</p><p>This is a good time to talk briefly about the use of hand drawn diagrams. We used the one from figure 34 to communicate when there was no system. We used the left of figure 36 to depict the delta between what existed and what was wanted. Hand drawn diagrams depict either wishes (when they are about the future) or beliefs (when they are about the present). As soon as the system exists, the diagram should be generated i.e. there should be no place for beliefs, only wishes. Designing systems is hard enough. Not knowing what your current system is and relying on beliefs should not be an acceptable variable.</p><h3>This seems like magic?</h3><p>At first glance this can look like a BPMN (Business Process Model and Notation) or a workflow engine but this is just because we are modeling a concept that looks like that. The idea of creating contextual visualizations applies to anything in the domain we want to model.</p><p>For example, in our scenario code, the definition of the steak had a price associated with it. Like this:</p><pre>sirloinSteak := Consumable new <br>    name: &#39;Sirloin steak&#39;;<br>    price: ((30 EUR asPrice discountedBy: 10 percent) discountedBy: 5 EUR).</pre><p>That price includes a couple of discounts like the discount by 10% or the one by 5 euro. Discovering the discounting mechanism also followed the same process as the one of discovering our order flow and it also came with its own tool and visualization as seen in figure 37. The price object was not specific to the restaurant industry but to any domain with finance within it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ssgSdMj5naeCRd3k" /><figcaption>Figure 37 — Visualization depicting discounted prices</figcaption></figure><p>Our restaurant business contained multiple languages — the language of order flow, the language of payment, the language of a specific object. When building our tool for the restaurant business, what we are in fact doing is creating a domain specific language by combining pre-existing languages with what is specific to the domain, Cozy Corner being a specific instantiation in that resulting language.</p><p>We are going to re-emphasise this part because it’s at the heart of why we can work so quickly. We don’t build solutions to a problem by writing code, we build the language of the problem. Then we use that language to solve the problem. That language is written in code and it always comes with a visualization (a tool) because building the tool is how we build the language.</p><p>The net effect of this is that we build domain specific tools for the problem and then we use those tools to solve the problem. Whilst most problems we face in technology are highly contextual — stuck cursor, cozy corner — there are a few highly recognizable and standard problems — HTTP load testing, code editing, DNS queries (see figure 38) — where ready made tools make sense and are available. Alas, we’ve been hoodwinked by tool vendors into believing that their tools are applicable everywhere which is unsurprising given their self interest. Kitchen blender salespeople will always sell you kitchen blenders for digging deep mine shafts if they could get away with it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*8-Wgl57HwmKzjs9y" /><figcaption>Figure 38. People recognizing a software engineering problem vs the problems</figcaption></figure><p>Despite tool vendor claims, for the majority of cases, to solve a problem we need to build a tool for that context. To communicate that problem, the tool needs to show a visualization of it but that requires a model. To build that model we benefit from creating the language of that highly contextual domain and in order to create that language we need to ask and answer questions. The process of asking and answering questions is captured in the development of the tool for a contextual problem. It’s also where we make our choices on what matters.</p><p>Hence, when dealing with a legacy migration project, we don’t start looking at or reading legacy code in a standard code editor, we start by building the tools to understand that legacy code and once we can effectively visualize the problem then we can migrate it. This is how you turn year-long migration efforts into a month: by spending the first three weeks building the tools you need. This isn’t magic, it’s just the result of rethinking what we mean by software engineering. Which is pretty convenient since the title of this book is “Rewilding Software Engineering”.</p><h3>A note on reason</h3><p>Language, medium and tools are core pillars for how we reason about the world around us. Any changes to these throughout history, such as the printing press (tool), the written word (language) and paper (medium), had profound effects on how we reason.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*XDctKwzMOnOAafp_" /><figcaption>Figure 39 — Pillars of reasoning</figcaption></figure><p>In the world of software engineering: the language, medium and tools have evolved over time leading to changes in how we reason both about and with the machine. For example, the language change from Fortran-like expression to message passing and protocols enabled us to create orders of magnitude larger systems. Today, languages are changing from exclusively deterministic to include non-deterministic forms such as prompts with LLMs.</p><p>The change of the medium through which we interact with the machine from text to GUI (graphical user interface) also changed how people adopted computation in their lives. Today, our medium is changing as well. In a traditional world of engineering we would often discuss the problem on a whiteboard and then translate this discussion to deterministic code (written text). The written text was the major medium of human to machine interaction. In a world of LLMs/LMMs then, the whiteboard (a mix of images and text) becomes a major medium of human to machine interaction, in which, the LLMs/LMMs often do the translation to deterministic code.</p><p>But, more than just inputs, the ability to visualize problem spaces is a critical part of the medium. This is not just in creating new business processes for the Cozy Corner but in how we understand problems. To give an example of why visualization matters and why it works, let us look at four constellations of ten small nodes like in figure 40. How many groups do you see in each constellation?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*VFsWTibbJJeMZiPX" /><figcaption>Figure 40 — Visual grouping of ten nodes</figcaption></figure><p>The answer to the question of “how many groups” depends upon what visualization is used. In the proximity configuration, you’d probably say three or possibly four — the only point of challenge being the node in the very center. In the enclosure, you’d probably say “two groups”. In the similarity or connectivity views then you’d probably say three. These pictures work because of our innate visual abilities. Visualization can be a powerful medium when leveraged appropriately.</p><p>Medium and language are changing. But what about tools? In our environment, the existing tool vendors are trying to persuade us that the tools of the future are the same tools they have sold us in the past plus added ChatGPT or equivalent. These future tools are commonly called copilots. Yes, they will add language elements (such as prompts) and will no doubt add medium elements (such as whiteboards). In 2025, it is clear that a copilot with a “build from a whiteboard” capability is just around the corner and an obvious (and somewhat tedious) change.</p><p>What this book argues is that we should use this opportunity to fundamentally change our tools as well and for those tools to become more contextual i.e. built to the problem. This might not be a popular message with tool vendors, but we have been sold a pig in a poke — we should have been using contextual tools all along. Now is the right time to change this.</p><p>These three concepts — of language, of medium, of tools — play off one another in Moldable Development. The practice of Moldable Development supports the creation of domain specific languages (as in the Cozy Corner example) for the problems you are looking at. Those languages may contain both deterministic and non deterministic forms but they are created through the process of building small contextual tools that can be combined in many ways. Those tools provide a highly visual medium for communication. By touching upon language, medium and tools then Moldable Development is in effect a way of reasoning about the world around us.</p><h3>Shallow and deep (mining) problems</h3><p>Ok, this has nothing to do with mining (or kitchen blenders). This has to do with how far we are from the problem we want to reason about.</p><p>To give an analogy, consider a stain you observe on the ceiling. You can just as well, say that it’s dirt and have it painted over. But what if the stain is a sign of a mold? Then you need to look beyond the thin paint layer and have the structure treated. But that stain can just as well be a leakage. In this case, the right solution is to go beyond the thin paint layer and the structure and look at the pipes. Limiting ourselves to observing only the outskirts of the system does not allow us to address or even understand anything but shallow problems. True understanding requires identifying root causes and that requires us to explore the system at various levels.</p><p>When the stain is just dirt, we are facing a shallow problem. When the stain is caused by the pipes, we have a deep problem on our hands. Yet, when we open the wall and get to the problematic pipes that should be replaced or patched, we are again facing a shallow problem.</p><p>Whether a problem is shallow or deep relates to the distance between the observation and the root cause. If we can peel off layers from our system and can explore them on demand, we can transform deep problems into shallow ones. A pipe leak is a relatively easy thing to fix. The hard part is knowing that the problem is a pipe leak and finding where the pipe leak is.</p><p>With the right tools even those harder problems can be broken down into more shallow problems. It’s why plumbers have tools like acoustic leak detectors, electronic leak detection, pipe inspection cameras and even use thermal imaging cameras. Notice how in the physical world, for every problem, we quickly break down into a plethora of tools, each designed for a specific kind of problem.</p><p>The same can happen with a software system. In this and previous chapters we offered examples at various levels of depth. In each case, when observed from outside the system, the problem looked deep and insurmountable. But when we dug deeper, it became shallow and tractable. You can observe this phenomenon using those questions and answers maps we introduced before (see figure 41).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-Lfkmai7OduH4A8p" /><figcaption>Figure 41 — Shallow and deep problems</figcaption></figure><p>An important point to recognize here is that questions at different levels are not necessarily provided by the same person, and that they require different levels of expertise. The houseowner asking about the stain often needs the plumber to ask about the source of the leak. Similarly, the business person wanting to know why the services are slow needs the technical person to navigate the technical details (see figure 42).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*XUtdLJoJs5DREOiN" /><figcaption>Figure 42 — Questions, answers and expertise (the answer to life, the universe and everything)</figcaption></figure><p>Those role variants — e.g., the manager, the architect or the developer — also point to who makes the decisions. Underneath the developer is the system itself and one of the interesting aspects of LLM/LMMs is the expansion of where the system makes choices for itself.</p><h3>To vibe or not to vibe?</h3><p>Given Eric Schmidt’s and others’ recent proclamations that software engineers will no longer be needed by the end of 2025, we need to return to the question of AI or more aptly the great seduction by it.</p><p>It’s probably worth clarifying a few popular terms here. These terms will change over time as people are still exploring and defining the field of generative AI. Software engineering is the act of making decisions in code. It can and often does use an AI as an assistant in this act but inspection of the code remains firmly in control of the human. Vibe coding (or as Simon prefers to call it vibe wrangling) is an exploratory style of programming where humans and AI work conversationally without the humans looking at the code.</p><p>Yes, you can use vibe coding to create marvellous prototypes. And both authors extensively use language models to do this. In the act of writing code, the coder is making decisions of what our system should look like. It should always be remembered that anything in the system, including what people call architecture or the ubiquitous domain language, is in the code. The one writing the code is the real architect and the real modeller.</p><p>When that coder is the AI then we are handing over control, decision making and understanding to the machine and that’s ok if it is something you trust the AI to do — for example, when working on a prototype. But when doing that, you are also deciding not to develop a language for that domain, not to model that system and not to build the tools to understand that context.</p><p>The troubles occur when you start to care about the result. At this point, you have no choice but to involve yourself in decision making. This often manifests itself through a review process i.e. we get the AI to code and then we review the code. In the case of technology, that means software engineering. Despite Mr. Schmidt’s claim, it is unlikely that software engineering is disappearing anytime soon. First, because building trust in AI systems is a social process. Second, because this assumes the AI systems are capable.</p><p>In addition, there is also a hidden assumption which is flawed. In early human history, we used to have scribes because literacy was not universal. The current ideas about AI have a hidden assumption that because the business has not in the past been able to be involved in software engineering that the the AI simply replaces those IT scribes rather than everyone becomes literate. It’s really important to grok this, from a business perspective using LLMs or using software engineers is the same thing because in both cases the business had no visibility into the system (see figure 43).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0fPmCuXXuAD7kAxj05wg1Q.png" /><figcaption>Figure 43 — The view of the system from a business perspective</figcaption></figure><p>However, the Cozy Corner example shows that there is a mechanism for universal literacy through the views created from the system. These views democratize the reading of systems in a way that is decoupled from their writing.</p><p>So, why not get an AI to write the views and we use these views to discuss with the AI through prompts? That’s the future we are arguing for: a human will still be able to make decisions about the system at a slightly higher layer than code review. The key here is that the human doesn’t get detached from the decision making in the same way that the business became detached from the technology choices being made. This is the heart of rewilding software engineering, exposing the workings of the system in a language that is universal (in this case views) without the necessity to read code. See figure 44.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*l9fJzouKgeN23Xy5u_6X0Q.png" /><figcaption>Figure 44 — Avoiding Black Boxes</figcaption></figure><p>So, why not use AI agents to discuss with AI agents (e.g. some to code, some to read and review the code) in the pursuit of a goal set by the human? You can, and there are some very interesting practices being developed here which we will explore in a later chapter. However, you cannot avoid handing over decision making to the AIs if you cannot review the system. The use of such agents once again puts the business back into a situation of the system being a black box that it can’t understand.</p><p>The most important architectural question of today is: at what point do I value human decision making? Investors in AI and tool vendors of AI will tell you that you don’t need to care about human decision making and that AIs don’t need humans but then, they have a self interest in sizzling up that story. Hence claims that we won’t need software engineers by the end of 2025 are common amongst this group.</p><p>In general, using AI is perfectly fine if:</p><ul><li>the system is not something you care about. This can be particularly useful for exploring new ideas about a space, much like how you could use AI to get you beyond the writer’s block in front of an empty page.</li><li>you are at the right level and see the right problem, you can specify what you want generated and you are also in the position to evaluate the AI’s output. Always remember that prompts are not a deterministic language and what you get back is the AI’s statistical interpretation of what you wrote, not necessarily what you were thinking.</li><li>you are at the right level to answer your question, but do not have a tool for answering the question, then you might be able to use AI to generate that tool or view for you.</li><li>you do not know where to look, you can also ask the AI for possible questions (even when they are presented as answers).</li></ul><p>Don’t get us wrong, the dopamine hit of getting something done with vibe coding can feel delightful, and because of this it’s easy to get carried away in the excitement. But the economic impetus to adopt AI is based on the premise that we have reached the peak of human productivity and the only way to increase that productivity is to either add more people or adopt AI which is much cheaper and abundant. But that assumption is wrong. We are far from knowing what humans are capable of in this space simply because there is no universal literacy.</p><h3>Bridging the gap</h3><p>Shallow and deep mining, vibe or not to vibe, the different roles involved (both human and AI) and where decisions matter (both human and AI) — there is a lot of content here but at the root of all these is the skill of asking and answering questions about the context of our systems. This requires a common language between all participants hence the importance of universal literacy.</p><p>It’s worth noting there are also specific skillsets involved because these might not be obvious in the first place. Unsurprisingly, those skillsets cover the asking of questions (the stakeholder role) and the provision of answers (the facilitator role).</p><p>In our Cozy Corner example, we have multiple stakeholders, starting with the software engineer implementing the message flow algorithm that had the need to visualize it for debugging purposes, to the domain experts (or business managers) that had the need to see the flow to come up with variations at the domain level.</p><p>In the case of the data pipeline example described in previous chapters, there were multiple stakeholders as well. We had the CIO that wanted to know why the system was not improving, we had architects that wanted to know what data is and is not used throughout the pipeline, and we had the software engineers that wanted to understand the impact of individual data changes. In general, anyone with a stake in the system is a stakeholder.</p><p>The stakeholder’s role is one of asking questions, posing hypotheses and of interpreting answers. Questions can have different goals, like seeking exploration, refining the landscape, understanding the space, or helping define a domain specific language, but they should always be timely, specific and actionable. Once stakeholders get answers, they should know how to transform them into action.</p><p>The provision of those answers is determined by the skill of the facilitator. While the stakeholder can be anyone, the facilitator is necessarily technical. They construct contextual tools that provide explainable, representative and accurate answers from the systems. In figure 45, we provide an overview of these roles.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*HiKuVul-S6t_VA65" /><figcaption>figure 45 — the role of facilitator and stakeholder</figcaption></figure><p>The facilitator is a support role and its function can be more clearly seen in the Q&amp;A map. In order to explore a problem domain, the facilitator helps to industrialise answers through the production of tools to solve that problem. This enables not only new possible questions (the adjacent unexplored) but also the shift of questions from the concrete but uncodified (“how is this piece of data traversing the data pipeline”) to the more abstract but codified (a tool to show how many data is traversing the data pipeline) — see figure 46. The facilitator can be viewed as being similar to a data scientist but for providing answers about systems, and not only domain data. Yes, this is a possible role for AI.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*dszx5O6BLRVGzHiE" /><figcaption>figure 46 — the facilitator is focused on commoditizing the answer</figcaption></figure><p>The interplay between the roles can be observed at the highest conceptual levels all the way to the most granular levels of exploration. Consider, for example, the dynamic exploration of the tokenization algorithm described in the previous chapter, as seen in figure 47. The contextual tools materialize answers, but their meaning is given by the overarching questions prompting the exploration.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*iBnADWuEiEEqbHI0" /><figcaption>Figure 47 -Stakeholders and tools: what are the resulting tokens?</figcaption></figure><p>For example, our first question is “How does tokenization work?”. This leads us to a sub question of “How does tokenization work for a given input?”. This we answer through building the first pane which contains a code snippet that executes the tokenization algorithm which in turn creates raw data. Examination of this raw data leads us to a new question of “What are the resulting tokens?” which we answer by creating a new dedicated view (the 2nd pane). Exploration of an individual token from this view, creates a third pane with raw data. This leads us to a new question of “How was a token constructed?” which we answer with a new view (the 3rd pane).</p><p>The choice of a view must be a conscious step. This can be harder than it appears when you are used to working with standard tools with constrained views that you try to fit into your question. When following Moldable Development, we start with the question and then build or pick the tool with an appropriate view that helps drive the exploration of that question.</p><p>This can, and does, create multiple paths for exploration. For example, in the scenario above having created the output for the snippet in pane 1 then we could go down a different path. Instead of exploring “What are resulting tokens?”, we could explore “What steps did the algorithm take?” leading up to the question of “What happened at each step?” (see figure 48). Navigating these pathways is a skill that the stakeholder must learn.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*o__AAoNcEoFE8EXe" /><figcaption>Figure 48 — Stakeholders and tools: what steps did the algorithm take?</figcaption></figure><h3>Roleplaying with AI</h3><p>How does AI fit into these roles? Is it a stakeholder, a facilitator or both? The answer to that question depends a lot upon context and time. For example, in today’s world, with our current systems, AI can act as a facilitator for prototypes and contextual tools. As its capabilities extend then that will change over time. Though these systems don’t reason (for now) despite sophisticated code generation, the combination of many agents can simulate such reasoning especially for shallow problems.</p><p>But, this is performative i.e. there is an appearance of competence without substantive problem solving. This can pose an issue when trying to solve deep problems. Hence, when a pattern is known or well defined or when we can quickly evaluate the output, then AI can act as a useful facilitator.</p><p>Perhaps unexpectedly, LLMs also have a role in asking questions (i.e. being a stakeholder) or at least coming up with alternative questions to ask. As time progresses, capabilities develop, practice co-evolve and trust is earned then that boundary of what we will use AI for will change.</p><p>We can summarize this all into one choice that needs to be continuously made, where does it matter to have humans involved in the decision making. The impact of LLMs is shown in figure 49 in both helping in the creation of hypotheses (a stakeholder role) and in generation of specific coding / tools (a facilitator role).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5gUmBzTkX8MrmS0Jg7SaUg.png" /><figcaption>Figure 49 — Stakeholders and Facilitators in decision making</figcaption></figure><h3>The reconcilliation</h3><p>We started this chapter with an apology and a description of how software engineers can appear to be unhelpful, pedantic and inflexible. This is mostly caused by the exclusion of business from the decision making in the systems which in turn is mostly caused in the current practices of software engineering. This is why we are writing the book, it’s not just for software engineers, it’s also to bring the business closer.</p><p>Challenging the nature of software engineering (our first wolf in our rewilding metaphor) and the importance of this being a decision making process is as much for engineers as it is to highlight how the business should be involved. This requires us to challenge the way in which we ask and answer questions (our second wolf) and in particular the tools and visualizations we use.</p><p>That may not be comfortable for some, but both wolves are needed if we ever want to end up somewhere cozy.</p><h3>What did we learn?</h3><p>This chapter adds several important new concepts.</p><p>Stakeholder and Facilitator roles: there exists discrete but complementary roles with different skillsets that formalize the relationship between questions and answers. Each of those roles is focused on a different aspect and governed by their own metrics — ttA (time to Answer) and ttQ (time to Question).</p><p>Language, medium, and tools as pillars of reasoning: There exists three elements that are foundational to how we reason about software systems which is an essential part of decision making. Instead of building solutions directly, we should aim to build the language of the problem first, which includes contextual tools to visualize and manipulate that problem space.</p><p>Deep and shallow problems: visualizations are critical for transforming deep problems into shallow ones by revealing the system’s inner workings.</p><p>Vibe Coding vs. Software Engineering: AI has a role in code generation, facilitation and as an assistant to stakeholders. That role will expand over time but the boundary between human and AI decision-making is an architectural choice that should be made deliberately based on where human understanding and control are valued.</p><h3>Homework</h3><p>For this chapter’s homework, we need you to inspect your own organization and current practices. This is mostly an exercise in self reflection considering aspects of this chapter.</p><p><strong>Step 1. Visualization audit:</strong><br>Examine your current development process. How many of your visualizations (diagrams, charts) are manually created beliefs about the system versus automatically generated reflections of the actual system? Create a plan to move at least one key visualization from manual to automatic.</p><p><strong>Step 2. Data sources audit:</strong><br>Examine how you get information about your systems. How many surveys did you have in the past 3 years that were asking teams about how they use or deploy technical capabilities (such as for clouds)? Pick one of them and from one of the questions explore what it would take to get the answer through a tool rather than by asking for opinions.</p><p><strong>Step 3. Role identification:</strong><br>Identify the stakeholders and facilitators for a system in your organization. Document the questions typically asked by stakeholders and how facilitators currently provide answers. Where are the gaps in this communication? Does the organization think about how we ask and answer questions or these different types of roles? As a concrete way to identify facilitators, start from Step 1 and Step 2 and ask yourself who would implement those tools.</p><p><strong>Step 4. Domain language exercise:</strong><br>Choose a small but important process in your organization. Sketch a domain-specific language that would describe this process. What are the key actors, messages, and rules? How would you visualize the flow?</p><p>—</p><h3>Rewilding Software Engineering</h3><p><a href="https://medium.com/feenk/rewilding-software-engineering-900ca95ebc8c">Chapter 1: Introduction</a><br><a href="https://medium.com/feenk/rewilding-software-engineering-083b86c81c43">Chapter 2: How we make decisions</a><br><a href="https://medium.com/feenk/rewilding-software-engineering-f758ec97ddb2">Chapter 3: Questions and answers</a><br><a href="https://medium.com/feenk/rewilding-software-engineering-a3601a066e50">Chapter 4: Flexing those thinking muscles</a><br>Chapter 5: Different folks for different strokes<br><a href="https://medium.com/feenk/rewilding-software-engineering-ca3ad1e612d8">Chapter 6: Myths we tell ourselves</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=70d24a750dff" width="1" height="1" alt=""><hr><p><a href="https://medium.com/feenk/chapter-5-different-folks-for-different-strokes-70d24a750dff">Rewilding software engineering</a> was originally published in <a href="https://medium.com/feenk">feenk</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Patterns & Basic Tools]]></title>
            <link>https://medium.com/mappingpractice/patterns-basic-tools-1f64e42e94ef?source=rss-280dd9543ba9------2</link>
            <guid isPermaLink="false">https://medium.com/p/1f64e42e94ef</guid>
            <category><![CDATA[wardley-maps]]></category>
            <dc:creator><![CDATA[swardley]]></dc:creator>
            <pubDate>Tue, 29 Apr 2025 17:27:23 GMT</pubDate>
            <atom:updated>2025-04-29T19:23:10.606Z</atom:updated>
            <cc:license>https://creativecommons.org/licenses/by-sa/4.0/</cc:license>
            <content:encoded><![CDATA[<h4>Stuff that I use</h4><p>When <a href="https://medium.com/wardleymaps">mapping</a>, there are some basic tools and patterns that I use regularly. At some point, I will get around to updating the book, probably when I retire. I’ve tried to put them in order of usefulness, key with mapping is keep it simple.</p><h4>A Wardley map</h4><p>Start with users, focus on user needs, work out the supply chain and ask how evolved the components are. Please note that this is recursive i.e. every component can be a map itself. You can go from a nation to the individual or from a business to the code. There are no fixed layers, so you bring whatever you need onto the map i.e. mixing social systems with individual code components is fine.</p><p>Maps are almost entirely produced in collaboration with others. This can vary from a couple of people drawing lines on a whiteboard to large online groups dissecting an entire industry from multiple perspectives.</p><p>Please note, there is no time axis on a map. Instead each map has a time and perspective from which it is written. At a minimum, record the time. <strong>Useful for creating a shared understanding, enabling communication and encouraging challenge.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*39LDF-gh64_3ymdWp1pNuA.png" /></figure><h3>THE REST</h3><p>It’s worth stating that stopping here and going no further is fine. Mapping should be simple and just being able to explain users, user needs, the supply chain of components and how evolved those components are is more than enough for most. The rest of this list can be ignored.</p><p>Some things to note:-</p><ol><li>Always remember that maps are imperfect representations of a landscape — in fact, they have to be in order to be useful.</li><li>The work is all creative commons share alike.</li><li>The work is only 20 years old. Our geographical brethren took a long time to learn how to map their landscapes, so think of mapping as still in its infancy.</li><li>There are no certified mapping courses or blessed mappers or official T-Shirts or any of that nonsense. All that exists are people with better maps. We are all still learning.</li></ol><p>That said, we will continue with the list which provides things you might want to think about or explore.</p><h4>Cheat Sheet</h4><p>Useful in helping to determine how evolved something is. This comes from the original text analysis that created the evolution curve that became the evolution axis of a Wardley map. If you can’t resolve an argument it normally means the component represents multiple components and you need to subdivide.<strong> Useful for creating consensus on the map.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*arAm6bfO8fpFxux2vpG_zg.jpeg" /></figure><h4>Strategy Cycle</h4><p>Basically, the underlying framework for mapping. The three basic forms of patterns are climatic patterns, doctrine and leadership. <strong>Useful for understanding how this all fits together.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ja7OlkrbTk3JC51vbZSQTQ.jpeg" /></figure><h4>Climatic Table</h4><p>These are the rules of the game. They happen to the map regardless of what you do because they are driven by aggregate forces (e.g. supply and demand competition). <strong>Useful for anticipating changes.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KxN3-WqxYKAbIbjU9Hd2iA.jpeg" /></figure><h4>Doctrine Table</h4><p>The list of universally useful principles that have come out of mapping. You don’t have to use them but I would suggest you should. You can also map out principles and the interconnections between them. Doing this enabled me to create the different phases. Start with phase I as the phase II principles will need them. <strong>Useful for organising companies.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wQEes-n6Cq-QziqsLiDp9w.jpeg" /></figure><h4>Leadership table</h4><p>This is a list of some of the basic gameplay patterns you can use on a map. Don’t start here, start with focusing on observing your landscape.<strong> Useful for manipulating markets.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nTln3OvAjX6rmJUFlYEDOA.jpeg" /></figure><h4>Inertia table</h4><p>Some of the climatic and doctrine patterns deal with inertia. There are many different forms. This is a handy guide. <strong>Useful for managing and thinking about inertia.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cUB0zVBkkTAgXmYVdJaNUA.jpeg" /></figure><h4>Methods analysis</h4><p>It’s one of the principles found in the doctrine table but it comes up so often that it’s worth calling out. <strong>Useful for challenging all those “one size fits” all approaches across project methods, purchasing and finance.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8KtJP2uOUyc2s2PPekm4eA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tKEkaKYE8ayqyFwE7SSG2g.png" /></figure><h4>Contract analysis</h4><p>More a technique but incredibly useful. Take a contract (and its related architectural diagrams) and then map it. Most contracts I come across are fundamentally flawed mixing in things which can’t be specified into specifications. <strong>Useful for stopping massive cost overruns before the contract is even signed.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N20pw31aWwl9OxfjjbbNTQ.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JvgZ5LKDPFzrrScAzM0WFw.jpeg" /></figure><h4>Profile diagrams.</h4><p>If you have enough maps in an organisation, then it’s not uncommon to create a profile diagram (by taking various nodes from different maps). <strong>Useful in discussions on bias and duplication.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-OXCIemxLrzvpj4X17hkqA.jpeg" /></figure><h4>Flow analysis</h4><p>There are two forms of flow on a Wardley map. Evolutionary flow (e.g. industrialisation of components) and capital flow (whether financial, knowedge or any other form of capital). The lines represent bi-directional flows of capital i.e. revenue for a cup of tea. <strong>Useful for aligning the map with existing capital flows and often discovery of missing parts.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DWoe2QGlZ538zliLNSGFIg.jpeg" /></figure><h4>Axis table</h4><p>From the cheat sheet — you don’t have to use genesis, custom built, product and commodity as the labels. You can mix and match, for example when mapping out ethical values I use the following.<strong> Useful for mapping beyond physical activities into economic, technological, social and political spaces.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Beq9H4pHuAWiuYeKvf21Bw.jpeg" /></figure><p>An example of use is in the culture map which seperately has <strong>uses in stabilising or destabilising cultures or in exploring beliefs within a culture.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*b-PvZIeJVRf2W_uqrxZ1Eg.jpeg" /></figure><h4>Peace, War and Wonder heat maps.</h4><p>This uses weak signals and it takes me time to produce. Don’t expect regular updates. A heat map of when major points of industrialisation (known as “war”) are going to occur. <strong>Useful for investment and shorting.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2doo3XwHCunIbl5JF0P3yw.jpeg" /></figure><h4>Population Studies</h4><p>Using maps, I run population studies on companies every decade looking for the change in characteristics / phenotype. The next one is 2031. <strong>Useful for identifying new principles (i.e. doctrine) but also for company comparison to an industry.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*thRDL51xZaU9tYwutgqcbQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3hT2GK85QO8Z7cQRNpVtPQ.jpeg" /></figure><h4>Sovereignty Maps</h4><p>When looking at issues of sovereignty, I’ll tend to create a map, apply climatic patterns and then work out where our borders should be. This is an example from DVLA in 2015, forecasting forward to 2025. Remember there are three basic forms of competition (striving with others) which are conflict (fighting others), collaboration (labouring with others) and co-operation (helping others). <strong>Useful for sovereignty discussions over economic, technological, social and political spaces.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mVFeMrulI4zRM86nytmtYg.png" /></figure><h4>Benefit tables.</h4><p>Developed from mapping an industry across multiple perspectives with large groups of people experienced in the field (this normally takes about ten hours). I then aggregate across maps for social versus market benefit. <strong>Useful for challenging long term social planning and finding overlaps between market and social needs.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TVj17wjALQzN2mnzbkls2Q.png" /></figure><h4>Predictabilty graph</h4><p>One thing you’ll learn with patterns is that often we can reasonably predict what is going to happen but not when, or, when something will happen but not what. <strong>Useful for understanding the limits of predictability.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*klc6Tm0tLtBJO03slaRfcA.jpeg" /></figure><h4>Evolution curve</h4><p>Underpins the evolution axis, created from the original text analysis which includes 9,223 publications. Don’t confuse this with diffusion. They are not the same. <strong>Useful for understanding why uncertainty is part of mapping (it literally underpins the axis).</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ikMH2rsqWRDvafNLs-F1tg.jpeg" /></figure><h3>Attitude table</h3><p>Explorers, villagers and town planners is a cell based structure that mixes maps, aptitude and attitude. It’s old (circa 2005/2006) and very dangerous unless you have most of the doctrine in place. It also requires a system of theft. <strong>Useful for thinking about organisational structure.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Zbr-JoqzeItSXfIO_56_aA.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o0FAOGs5TyNaMgue4GVThQ.jpeg" /></figure><p>We could go on but these are some of the basic tools I use.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1f64e42e94ef" width="1" height="1" alt=""><hr><p><a href="https://medium.com/mappingpractice/patterns-basic-tools-1f64e42e94ef">Patterns &amp; Basic Tools</a> was originally published in <a href="https://medium.com/mappingpractice">MappingPractice</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>