<?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 Sven-Torben Janus on Medium]]></title>
        <description><![CDATA[Stories by Sven-Torben Janus on Medium]]></description>
        <link>https://medium.com/@sventorben?source=rss-1a1f818fe03d------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*0D2iUhQS_8VsOI0Dj6S3JQ.jpeg</url>
            <title>Stories by Sven-Torben Janus on Medium</title>
            <link>https://medium.com/@sventorben?source=rss-1a1f818fe03d------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 10:40:24 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@sventorben/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[The Engineer Who Never Learned to Code Alone]]></title>
            <link>https://sventorben.medium.com/the-engineer-who-never-learned-to-code-alone-c1d5a38eb20e?source=rss-1a1f818fe03d------2</link>
            <guid isPermaLink="false">https://medium.com/p/c1d5a38eb20e</guid>
            <category><![CDATA[future-of-work]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[consulting]]></category>
            <dc:creator><![CDATA[Sven-Torben Janus]]></dc:creator>
            <pubDate>Wed, 07 Oct 2026 20:08:04 GMT</pubDate>
            <atom:updated>2026-10-08T05:45:50.422Z</atom:updated>
            <content:encoded><![CDATA[<h3>AI is not only changing how we produce software. It is changing how expertise develops — and what expertise means.</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-HD0qGtNlq3vnO4blekDhw.png" /></figure><p>The most interesting junior engineer of the next decade may have no memory of learning to program without an AI beside them.</p><p>They may never spend an afternoon searching documentation for the signature of an unfamiliar API. They may rarely begin with an empty file. Instead, they might learn a new framework by asking an agent to build something with it, interrogating the result, breaking it, replacing parts of it, and comparing several alternative implementations before an earlier generation would have finished the tutorial.</p><p>They may write less code than we did and know fewer APIs by heart. Some of the mechanical fluency that experienced developers still associate with competence may never develop in quite the same way.</p><p>That does not necessarily make them weaker.<br>They may become better engineers.</p><p>Much of the current discussion about AI and junior developers starts from a different assumption. AI absorbs junior tasks; companies therefore need fewer juniors; juniors lose the repetitive work through which previous generations learned; and eventually there are fewer seniors because nobody has travelled the road that made seniors before.</p><p>There is a legitimate concern hidden inside that story. But it assumes that tomorrow’s expertise will look sufficiently like yesterday’s that our main task is to preserve the old route towards it.</p><p>Perhaps that is the wrong problem.</p><p>AI may not merely disrupt the pipeline through which we developed the old expert. It may change the kind of expert worth becoming.</p><p>If that is true, the interesting question is no longer simply where tomorrow’s senior engineers will come from. It is what a senior engineer should be when machines can perform an increasing share of the work through which we used to acquire, demonstrate and recognize seniority.</p><p>A few things begin to matter much more once that happens: the distinction between performance and capability; the ability to evaluate what we delegate; the experiences through which judgment develops; the understanding that has to survive abstraction; and the responsibility that remains human even when execution does not.</p><p>Those are not five new skills to add to an AI curriculum. They are boundaries around a deeper problem.</p><p>For much of engineering history, doing the work, understanding the work and becoming qualified to own the consequences of the work were closely connected.</p><p>AI is beginning to separate them.</p><h3>Output is no longer evidence of capability</h3><p>A randomized controlled trial at the Technical University of Munich provides a useful place to begin. Researchers assigned 275 introductory-programming students to three groups. One used a specially designed AI tutor that provided calibrated assistance. Another had unrestricted access to ChatGPT. A third relied on conventional web resources.</p><p>The AI-supported groups performed better on the programming task. Yet that stronger immediate performance did not translate into correspondingly greater measured gains in conceptual knowledge or code comprehension.</p><p>The experiment is deliberately narrow: one university, one introductory course, one 90-minute exercise. It would be irresponsible to turn it into a general claim that AI does not help people learn programming.</p><p>But the result demonstrates something more modest and more important: <strong>better performance and greater capability can diverge</strong>.</p><p>Another 2026 paper, this time in <em>Computer Applications in Engineering Education</em>, reported four experiments examining generative AI in different roles during programming education. One of its findings is particularly relevant here: when AI acted as a problem solver, students performed better on the task at hand, but the improvement did not transfer to subsequent tasks they completed without AI assistance.</p><p>Again, this is not evidence for a universal law. It is evidence that we need to distinguish what a person can accomplish with a system from what that interaction leaves behind in the person.</p><p>That distinction has always existed. Developers could copy code they did not understand. Students could reproduce known solutions. Consultants could apply a framework whose underlying reasoning they had never really internalized.</p><p>AI changes the scale.</p><p>A novice can now produce an artifact dramatically beyond their unaided capability. This is an extraordinary expansion of what beginners can do, but it also creates an epistemic problem for every organization that develops technical talent. A strong artifact increasingly tells us something about the human-machine system that produced it, and less about the unaided capability of the individual inside that system.</p><p>Imagine our AI-native junior completing in forty minutes something that once took us a day. The interesting question is no longer whether they were productive. They obviously were.</p><p>The question is: <strong>what remains inside the engineer after the task is finished?</strong></p><p>The research does not justify a pessimistic answer to that question. In fact, another 2026 randomized experiment points towards a much more hopeful one.</p><p>Researchers working with 124 undergraduate programming students compared ordinary generative-AI use with a seven-week structured approach built around decomposition, reflection, debugging, verification and progressively scaffolded interaction. Students in the structured condition showed stronger gains in higher-order thinking and a smaller but statistically significant improvement in programming logic. The study was conducted at one institution and did not measure long-term retention beyond the intervention, so its external validity remains limited. But it matters because both groups had access to generative AI. What differed was <strong>how they learned to think with it</strong>.</p><p>That changes the argument.</p><p>The problem is not that AI necessarily prevents the development of expertise. The problem is that <strong>output no longer guarantees it</strong>.</p><h3>Production no longer guarantees apprenticeship</h3><p>For decades, software organizations solved two problems with much of the same work. They produced software and, almost as a by-product, developed software engineers.</p><p>Junior developers fixed bugs, implemented modest features, read code they did not understand, made assumptions that failed, and watched experienced colleagues reject solutions that looked perfectly reasonable. They encountered databases containing twenty years of business history disguised as schema design, APIs whose real semantics were nowhere in the documentation, and systems that behaved differently from the architecture diagrams used to describe them.</p><p>Eventually the tasks became larger, then the decisions, and finally the consequences.</p><p>Nobody designed this system particularly well. It contained enormous amounts of wasted time, bad mentorship, avoidable frustration and pointless repetition. But it had one important property: the productive system and the learning system were partially the same system.</p><p>The company needed work done, and doing that work repeatedly exposed less experienced people to reality.</p><p>AI begins to uncouple those functions. The small implementation that once had to be given to a junior can increasingly be generated by an experienced engineer working with an agent. Migration scripts, tests, first-pass diagnoses, documentation and research become cheaper.</p><p>This does not require junior jobs to disappear for the apprenticeship problem to appear. The structural change happens earlier:</p><p><strong>The work an organization needs performed and the work a person needs to perform in order to develop expertise are no longer necessarily the same work.</strong></p><p>We should not respond by protecting every old task from automation.</p><p>Engineering culture has a bad habit of turning yesterday’s poor tooling into today’s character-building exercise. Remembering an API signature is not deep understanding. Writing boilerplate manually does not create architectural judgment. Spending two hours searching for a known error is not inherently more educational than finding the explanation in two minutes.</p><p>The relevant distinction is not between easy and difficult work, or manual and automated work.</p><p>It is between friction that was merely inefficient and experience that was cognitively formative.</p><p>Educational psychology has a useful concept for this: <em>cognitive offloading</em>. We have always externalized cognition into notebooks, calculators, search engines, documentation and software tools. Daiki Nakamura’s recent work in <em>Educational Psychology Review</em> argues that generative AI makes the boundary especially important because the same system can either support or bypass the mental process a learner is supposed to develop.</p><p>If I am learning architecture, letting an agent produce deployment syntax may free capacity for thinking about boundaries, failure modes and trade-offs. If recognizing those boundaries is precisely what I am supposed to be learning and the agent identifies them for me, the same tool may remove the learning event.</p><p>Nakamura calls the ability to manage this boundary <em>offloading regulation</em>. His paper is a theoretical synthesis rather than a new experiment, so it should not be mistaken for causal proof. But the distinction gives us a much better question than “should juniors use AI?”</p><p>The real question is:</p><p><strong>Which cognitive work can be externalized without weakening the capability we care about — and which work has to become part of the person?</strong></p><p>That is where the apprenticeship has to be redesigned.</p><h3>Tomorrow’s expertise may not look like yesterday’s</h3><p>At this point, experienced engineers often reach for the word <em>fundamentals</em>.</p><p>The instinct is right. The definition may need work.</p><p>An engineer in 2035 may remember fewer library calls than an engineer in 2020. I do not find that particularly troubling. They may author much less code personally and never develop some forms of implementation speed we once celebrated.</p><p>None of those things tells us, by itself, whether they can engineer.</p><p>What matters more is whether they can explain why a system behaves as it does, construct a useful causal model of something they did not personally build, discover the assumption hidden inside a plausible solution, and predict what changes when the system leaves its normal operating regime.</p><p>Can they distinguish evidence from a convincing explanation? Can they tell when two individually reasonable requirements cannot both be satisfied? Can they recognize when another prompt will not solve the problem because what is missing is a decision? Can they determine what evidence would justify trusting an answer?</p><p>And can they recognize when they no longer understand enough to delegate responsibly?</p><p>A fundamental is therefore not necessarily something professionals used to perform manually. It is a capability whose absence makes their judgment unreliable.</p><p>An architect does not need to implement a database engine, but an architect making certain distributed-system decisions needs to reason about consistency. A security engineer does not have to write a cryptographic primitive but must understand enough cryptography to recognize dangerous use. An engineer reviewing AI-generated code may not need to have authored every line, but somebody needs the mental model required to know whether the implementation preserves the system’s invariants.</p><p>There is an obvious objection here: every generation says this.</p><p>Compilers were going to make programmers forget the machine. IDEs would make us dependent on tooling. Search engines would destroy memory. Stack Overflow supposedly created developers who could paste answers without understanding them.</p><p>Often, the pessimists overstated the danger. Software engineering has always progressed by moving work into lower layers and building at a higher level of abstraction.</p><p>That is not an argument against the present concern. It is the reason to state it more precisely.</p><p>The issue is not that AI is the first abstraction capable of making us forget things. It is not. Nor is reasoning itself some untouched territory that previous tools never supported; debuggers, documentation and search have long participated in our thinking.</p><p>What has changed is the breadth of the delegation. A single system can now participate in problem decomposition, design, implementation, debugging, explanation, testing and review. The abstraction boundary can move across several cognitive stages of the same task at once.</p><p>The old engineering rule still applies: abstraction is enormously valuable as long as enough understanding survives underneath it to recognize when the abstraction has failed.</p><p>AI does not make fundamentals obsolete.<br>It forces us to decide which ones still anchor judgment.</p><h3>The AI-native junior may be better than us</h3><p>Once expertise is defined that way, something interesting happens to the junior engineer in our story.</p><p>Imagine that they never develop some of our mechanical skills because there is little reason to do so. From the beginning, however, they learn to state intent before implementation. They habitually ask for several approaches rather than becoming attached to the first one they happened to write. They generate counterexamples, ask the model to attack its own reasoning, compare competing designs and inspect systems that would once have been too large for them to explore.</p><p>They learn to distinguish a claim from the evidence required to support it. They can create a failure scenario, observe the behavior, modify the hypothesis and run another experiment in minutes. They may examine fifty architectural alternatives in the time an earlier engineer could realistically have experienced five.</p><p>That engineer has not necessarily had less experience because they have typed less.</p><p>They may have had <strong>more relevant experience per unit of time</strong>.</p><p>This is where the optimistic and pessimistic accounts of AI-assisted engineering meet.</p><p>A junior who uses AI to encounter more architectures, more errors, more uncertainty and more consequences can develop faster than we did. A junior who reaches for AI exactly when they would otherwise need to form a hypothesis, notice a contradiction or construct a mental model can become enormously productive without developing judgment at the same rate.</p><p>Both can produce excellent code.<br>That is why we will increasingly have to look beyond the artifact.<br>The objective should not be maximum unaided production, and it should not be maximum automation.</p><p>It should be <strong>maximum exposure to consequential engineering decisions per unit of time</strong>.<br>Experience should be compressed, not eliminated.</p><h3>Enterprise engineering starts where the benchmark often ends</h3><p>There is another reason this distinction matters in practice.</p><p>Most evaluations of coding systems begin after one of the hardest parts of engineering has already happened: somebody has decided what problem is worth solving.</p><p>There is a repository. There is a task. There is an expected result. The system is judged on whether it can get from one to the other.</p><p>Enterprise engineering often begins earlier.</p><p>What exactly is the problem? Which requirement is real? Which one describes a process that ceased to exist five years ago? Which constraint is technical and which one is contractual, regulatory or organizational? Who actually owns the decision? Which supposedly new solution has already been considered twice before?</p><p>The repository is not the system.</p><p>The system also includes historical data, undocumented consumers, operating procedures, contracts, manual workarounds, organizational boundaries and people who know that the process in the documentation is not the process the company actually runs.</p><p>This is also why the current fascination with “context” needs qualification. Context is often treated as information that can simply be collected and placed in front of a model. Sometimes it can. But important enterprise context is frequently interpretive.</p><p>A requirement says what it says because two departments never resolved a disagreement. An interface officially has an owner, but everyone knows nobody is willing to change it. A control that appears redundant exists because of an audit six years ago. An ugly data model is not simply technical debt; it encodes a business model the company never consciously decided to retain.</p><p>More tokens do not automatically turn institutional history into understanding.</p><p>A small episode from my own work captures the difference.</p><p>Years ago, a colleague and I were asked to evaluate whether a particular IAM protocol could be replaced. The technical alternatives were not especially mysterious. The obstacle was elsewhere: another legacy system imposed a constraint that made the replacement impractical.</p><p>A year later, the question came back. The constraint had not changed, so neither had the answer.</p><p>Another year passed. By then my former colleague had also moved into consulting, and we were both invited to another meeting about the same replacement. He arrived first. When I entered the room, we looked at each other.</p><p>“Did something change?”<br>“No.”<br>“So what are we doing here?”</p><p>In one sense, the work was already done.</p><p>Of course, we still held the meeting. There were new people in the room, including junior colleagues who had never seen the previous attempts. We reconstructed the problem, discussed the dependency and went through the options.</p><p>What had taken us seconds to recognize took much longer to reconstruct for everyone else.</p><p>The difference was not that we knew more about the protocol.</p><p>We knew <strong>which fact determined the answer — and what would have to change before a different answer became possible</strong>.</p><p>That is a form of expertise that becomes easy to underestimate in an AI discussion. The relevant knowledge was not a technical fact waiting to be retrieved. It was the history of the problem and the ability to distinguish a determining constraint from all the information surrounding it.</p><p>An AI system may eventually reconstruct that history better than we can. I see no reason to assume otherwise. But the capability still has to exist somewhere in the decision-making system: recognizing which change in reality makes an old conclusion worth revisiting.</p><p>Our junior engineer does not need to spend three years personally rediscovering the same constraint. What they need is to be present when someone exposes the reasoning: <em>this is the variable that matters; this is why the other information does not change the decision; this is what we would need to observe before reopening the conclusion.</em></p><p>That is what it means to compress experience without eliminating it.</p><h3>The dangerous organization will look extraordinarily productive</h3><p>None of this is a theoretical problem for some future generation.</p><p>Large randomized field experiments already show that coding assistants can materially increase developer output. A 2026 <em>Management Science</em> paper combining experiments at Microsoft, Accenture and a Fortune 100 company covered 4,867 developers and found a roughly 26 percent increase in completed tasks among developers given access to an AI coding assistant, although the individual experiments were noisy and effects varied. Less experienced developers showed higher adoption and larger productivity gains.</p><p>That study measured productivity, not expertise development. We should not pretend it answers a question it did not ask.</p><p>But that is precisely why it is useful here.</p><p>Imagine an organization that captures these productivity gains exceptionally well. Fewer people deliver more. Backlogs shrink. Tests, migrations and documentation appear faster. Small teams complete projects that previously required much larger groups.</p><p>Management has measurable evidence that the transformation is working.</p><p>Meanwhile, something harder to observe may be happening underneath. The organization’s output grows faster than the number of people capable of explaining the systems, challenging their assumptions or reasoning through unusual failures. Architectural and domain knowledge becomes concentrated in a smaller group while everyone else becomes extremely effective at operating intelligent machinery inside known patterns.</p><p>The organization has not eliminated expertise.<br>It has concentrated it.</p><p>That may produce excellent economics for years. It may also produce fragility. The weakness becomes visible only when regulation changes, a system crosses an unexpected boundary, two plausible recommendations conflict, a vendor disappears, or production enters a state nobody encoded into the normal workflow.</p><p>The risk is therefore not simply “AI makes people stupid.” That is neither demonstrated by the evidence nor particularly useful.</p><p>The more serious possibility is organizational: <strong>capability can grow in one dimension while decaying unnoticed in another</strong>.</p><p>The most dangerous AI transformation may be one that maximizes measurable productivity while silently reducing the organization’s future capacity to exercise judgment.</p><p>We know how to measure the first.<br>We are much worse at measuring the second.</p><h3>What should expertise become?</h3><p>This brings us back to the question promised at the beginning.</p><p>What should the engineer who never learned to code alone actually become capable of?</p><p>The answer is not another catalogue of AI skills. Prompting, agent orchestration, model evaluation, architecture, cybersecurity, communication, domain knowledge and critical thinking can all matter, but a growing list does not give us a theory of expertise.</p><p>A better starting point is to ask what an expert is for.</p><p>Once intelligent machinery becomes part of the cognitive system, the expert is not necessarily the person capable of personally executing every important operation. The expert is the person — or sometimes the team — capable of maintaining enough understanding and evaluation capacity to make consequential judgments about the system as a whole.</p><p>Five principles follow from that.</p><p><strong>Performance and capability must remain distinguishable.</strong> If AI can amplify output far beyond unaided competence, universities and employers can no longer infer understanding from artifact quality alone.</p><p><strong>Delegation must not outrun evaluation capacity.</strong> That capacity does not reside only in the human mind. Tests, type systems, static analysis, property-based testing, observability, simulation and carefully designed AI evals all allow us to delegate more safely. Good engineering has always multiplied human judgment with mechanisms that catch mistakes. AI makes investment in those mechanisms more important, not less. But no technical evaluation system eliminates the need for someone to understand what properties matter enough to evaluate.</p><p><strong>Experience should be compressed rather than removed.</strong> AI should help engineers encounter more architectures, more failures, more hypotheses and more consequences in less time. If it merely removes the moments in which they would have needed to confront uncertainty and revise a mental model, faster work has become slower development.</p><p><strong>Understanding has to survive abstraction.</strong> Nobody needs to know every layer of a modern system. But enough of the relevant model has to remain accessible somewhere to notice when reality and explanation diverge. The purpose of abstraction is to make complexity manageable, not to make ignorance indistinguishable from competence.</p><p>Finally, <strong>responsibility cannot be delegated merely because execution can</strong>. The person accepting a migration risk, architectural compromise or security trade-off need not have personally executed every intermediate step. They do need enough understanding of the decision, its uncertainty and its possible consequences to own it.</p><p>These principles are not arguments against AI.</p><p>They are the conditions under which increasingly powerful delegation remains engineering rather than dependency.</p><h3>Apprenticeship becomes progressive ownership</h3><p>If the destination changes, apprenticeship has to change with it.</p><p>The answer is not to prohibit AI until engineers have suffered through some historically appropriate quantity of manual work. Nor is it to hand everyone an agent and assume experience will somehow accumulate around the output.</p><p>A better model is progressive ownership.</p><p>A team lead can start doing this without redesigning the company’s entire training program.</p><p>Before running an agent, ask the junior to predict what kind of solution it will produce and where it is likely to fail. This forces a mental model to exist before the answer arrives.</p><p>Before delegating an implementation, ask for the invariant or acceptance property first. Let the machine write the code, but make the engineer state what must remain true.</p><p>Give them an AI-generated pull request containing several deliberately planted problems: one obvious bug, one architectural violation and one change that is locally correct but wrong for the surrounding system. The exercise is not to find syntax errors. It is to distinguish correctness at different levels.</p><p>For an architecture proposal, let the agent produce three credible options. Then ask the engineer which fact about the real organization makes one of them impossible. If they cannot answer, the next task is not another prompt. It is discovering that fact.</p><p>After an incident diagnosis, ask a question that should become habitual: <strong>what observation would prove this explanation wrong?</strong></p><p>These are small exercises, but they invert the normal use of AI. Instead of evaluating how much work the agent can remove, they use the agent to create more opportunities to exercise judgment.</p><p>The tools themselves can participate in this apprenticeship. An AI tutor does not have to answer immediately. It can ask for a hypothesis first, request a prediction, expose one missing piece at a time, challenge an explanation, or refuse to reveal the next step until the learner has committed to a model.</p><p>The programming studies mentioned earlier are interesting precisely because structured interaction performed differently from unrestricted assistance. That should encourage us. AI does not have to sit outside the learning process as a temptation we reluctantly permit.</p><p>It can be deliberately designed into the learning process. What matters is whether the interaction continually transfers more responsibility to the person.</p><p>Observation becomes participation. Participation becomes judgment under supervision. Judgment becomes responsibility. Responsibility eventually becomes authority.</p><p>The aim is not independence from AI.<br>It is the ability to remain intellectually responsible while using it.</p><h3>We will need different evidence of competence</h3><p>This also changes how we recognize expertise.</p><p>If high-quality artifacts become cheap, artifacts become weaker evidence about the person who produced them. The pull request tells us less about the engineer. The polished design document tells us less about the architect. The beautifully structured analysis tells us less about the analyst.</p><p>Organizations will have to observe reasoning more directly.</p><p>Can the engineer explain the system without asking an agent to reconstruct the explanation for them? Can they notice that the problem statement itself is incoherent? Can they identify which uncertainty actually matters? Can they predict the blast radius of a change? Can they recover after the model’s first three hypotheses are wrong?</p><p>Can they explain why they delegated one cognitive operation but retained another? Can they describe the evidence that would make them change their conclusion?</p><p>And perhaps most importantly, can they say: “I don’t understand this well enough yet to own the decision.”</p><p>That sentence may become a more valuable indicator of expertise in a world where convincing certainty is available on demand.</p><h3>The engineer who never learned to code alone</h3><p>We are approaching a generation of engineers for whom AI will not feel like a technology that arrived during their career. It will simply be part of the environment in which thinking happens.</p><p>Our generation will be tempted to judge them by what they no longer do: how much code they write unaided, how many details they remember, whether they can reproduce the apprenticeship that produced us.</p><p>That would tell us more about ourselves than about them.</p><p>They will almost certainly lose some capabilities we possess. Some losses will matter. Others may prove about as consequential as losing the ability to optimize assembly by hand after compilers became better.</p><p>In return, they may develop capabilities earlier that took us years to acquire — if we create environments that expose them to more decisions, more evidence, more failure and more reality rather than merely more generated output.</p><p>This is not only the responsibility of the next generation.</p><p>Universities need to decide which cognitive capabilities students still have to internalize. Engineering organizations need to capture AI productivity without accidentally dismantling their own mechanisms for developing engineering judgment. Experienced practitioners need to distinguish the hardship that merely happened to us from the experience that actually made us trustworthy — while also accepting that deep experience does not exempt us from learning to work effectively with a new generation of tools.</p><p>And managers will need to stop assuming that because work is being completed, capability is necessarily being created alongside it.</p><p>The temptation will be to call all of this <em>upskilling</em>.<br>It is something larger.</p><p>AI is separating three things we once treated as though they naturally belonged together: <strong>doing the work, understanding the work, and becoming qualified to own the consequences of the work.</strong></p><p>For much of engineering history, doing the first was one of the primary ways we developed the second. Years of demonstrating the second were how we eventually earned the third.</p><p>That sequence is breaking.</p><p>We should not respond by recreating it artificially.<br>We should discover what replaces it.</p><p>The central challenge of AI-native engineering is therefore not to preserve every capability humans once needed, and it is not to make engineers independent of increasingly capable machines.</p><p>It is to determine which capabilities remain necessary for judgment, deliberately create the experiences through which those capabilities can develop, and increase our ability to evaluate what we delegate.</p><p>The engineer who never learned to code alone may not resemble the senior engineer we know today.</p><p>That is not necessarily a failure of education.<br>It may be its next challenge.</p><p>The goal is to ensure that, as more intelligence becomes external, <strong>understanding, judgment and responsibility do not disappear across the same boundary.</strong></p><h3>References</h3><ol><li><strong>Patrick Bassner, Ben Lenk-Ostendorf, Ramona Beinstingel, Tobias Wasner, and Stephan Krusche</strong>. “Less stress, better scores, same learning: The dissociation of performance and learning in AI-supported programming education.” <em>Computers &amp; Education: Artificial Intelligence</em>, Vol. 10, 100537, 2026. DOI: 10.1016/j.caeai.2025.100537. <a href="https://doi.org/10.1016/j.caeai.2025.100537">Publisher / DOI</a></li><li><strong>Pinaki Chakraborty</strong>. “Effect of Using Generative Artificial Intelligence in Different Roles in a Course on Computer Programming.” <em>Computer Applications in Engineering Education</em>, Vol. 34, Issue 4, e70223, 2026. DOI: 10.1002/cae.70223. <a href="https://doi.org/10.1002/cae.70223">Wiley / DOI</a></li><li><strong>Jemimah Nathaniel, Solomon Sunday Oyelere, Jarkko Suhonen, and Matti Tedre</strong>. “An experimental study of structured generative AI integration to mitigate pedagogical, cognitive, and ethical barriers in programming education.” <em>Frontiers in Computer Science</em>, Vol. 8, 1789829, 2026. DOI: 10.3389/fcomp.2026.1789829. <a href="https://doi.org/10.3389/fcomp.2026.1789829">Frontiers / DOI</a></li><li><strong>Daiki Nakamura.</strong> “Augmentation or Erosion? Regulating Cognitive Offloading in Generative AI-Supported STEM Learning.” <em>Educational Psychology Review</em>, Vol. 38, Article 124, 2026. DOI: 10.1007/s10648–026–10224–6. <a href="https://doi.org/10.1007/s10648-026-10224-6">Springer / DOI</a></li><li><strong>Kevin Zheyuan Cui, Mert Demirer, Sonia Jaffe, Leon Musolff, Sida Peng, and Tobias Salz.</strong> “The Effects of Generative AI on High-Skilled Work: Evidence from Three Field Experiments with Software Developers.” <em>Management Science</em>, published online February 27, 2026. DOI: 10.1287/mnsc.2025.00535. <a href="https://doi.org/10.1287/mnsc.2025.00535">INFORMS / DOI</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c1d5a38eb20e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[When Software Teams Stop Writing Code]]></title>
            <link>https://sventorben.medium.com/when-software-teams-stop-writing-code-0b3ab7d5a38f?source=rss-1a1f818fe03d------2</link>
            <guid isPermaLink="false">https://medium.com/p/0b3ab7d5a38f</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Sven-Torben Janus]]></dc:creator>
            <pubDate>Wed, 14 Jan 2026 22:09:03 GMT</pubDate>
            <atom:updated>2026-01-14T22:09:03.478Z</atom:updated>
            <content:encoded><![CDATA[<p>Why software engineering is moving beyond optimizing developers and teams</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rqkjeBYf21-ov4knHIFztw.jpeg" /></figure><p>For most of its history, software engineering optimized for the individual developer.</p><p>Better languages, better frameworks, better tools — all designed to make one person faster at writing code. Even collaboration was framed as a way to remove friction from individual work. Teams mattered, but mostly as a coordination layer around personal productivity.</p><p>That model has already broken once. And it is breaking again — quietly, structurally, and without much ceremony.</p><p>That era is ending.</p><p>Not because developers are becoming less important, but because they are no longer the only actors in the system of work. The arrival of autonomous AI coding agents does not merely add a new tool to the toolbox. It introduces a new kind of participant — one that executes, explores, synthesizes, and verifies at machine speed, without belonging to the social structures that once defined teams.</p><p>The mistake many organizations make is to treat this as a productivity upgrade. Autocomplete, but better. Code generation, but faster. A way to squeeze more output from the same organizational shape.</p><p>That framing will fail.</p><p>What is changing is not how code is written. It is how work is decided.</p><h3>From Individual Productivity to Collective Intelligence</h3><p>When continuous integration was introduced, it did not primarily speed up commits. It changed how teams <em>thought</em> about delivery. Integration stopped being an event and became a property of the system. The unit of optimization shifted subtly — from individual developers to the pipeline itself.</p><p>Coding agents create a similar shift, but at a deeper level.</p><p>Once execution becomes cheap, abundant, and parallel, the bottleneck moves. The limiting factor is no longer the ability to produce code, but the ability to decide what should exist, what should change, and what should be trusted. Optimization migrates from individuals to the collective intelligence of the team.</p><p>Organizations that continue to evaluate AI agents as personal accelerators will see modest gains. Organizations that redesign teams around agents as collaborators will see a qualitative change in how software is built.</p><p>Because agents do not just generate output. They surface assumptions. They expose inconsistencies. They execute decisions faster than humans can emotionally process them.</p><p>And that forces systems to become explicit.</p><h3>Teams Are Becoming Architectures</h3><p>In traditional teams, boundaries were informal. Ownership was social. Authority was negotiated. Much of this worked because execution was slow enough for ambiguity to be absorbed.</p><p>Agents remove that buffer.</p><p>When a non-human actor can modify code, refactor systems, or explore solution spaces continuously, vague boundaries stop working. Prompts are not enough. What matters is who owns which decisions, what escalation looks like, and where judgment must remain human.</p><p>Conway’s Law does not disappear in this world. It sharpens. Organizational structure now governs not just code boundaries, but agent orchestration. Teams that fail to make authority explicit will find that their agents faithfully reproduce their confusion — at scale.</p><p>Designing teams therefore becomes an architectural activity.<br>Not metaphorically.<br>Literally.</p><h3>Why Workflow Becomes the Product</h3><p>As agents take over execution, code loses its status as the primary artifact.</p><p>This is uncomfortable for engineers trained to treat code as the durable outcome of their work. But code has always been ephemeral. What endured were the decisions that shaped it — and the processes that allowed those decisions to evolve.</p><p>In an agent-augmented world, workflows become the stable asset.</p><p>Planning workflows. Refactoring workflows. Incident-response workflows. These define not just what happens, but <em>how learning is incorporated</em>. Agents execute workflows relentlessly. Humans are responsible for evolving them.</p><p>The critical question shifts accordingly. Not “what did the agent produce?”, but “why did our workflow allow this result?”</p><p>Teams that understand this will stop debugging outputs and start debugging systems.</p><h3>Shared Context Beats Bigger Models</h3><p>It is tempting to believe that better agents require larger context windows. <br>More memory. More tokens. More state.</p><p>This is a dead end.</p><p>The real constraint is not memory, but coherence. Agents perform best when operating within shared, externalized mental models — artifacts that encode how the system is supposed to behave.</p><p>Architecture decisions. Domain language. Invariants. Constraints that can be checked rather than remembered. In such environments, agents do not hoard context. They amplify it.</p><p>The competitive advantage moves to teams that externalize knowledge systematically, not to those who rely on increasingly capable models to infer what was never made explicit.</p><h3>Governance as an Enabler, Not a Brake</h3><p>Autonomous agents force an uncomfortable clarity.</p><p>Who is allowed to change what? What does “safe” mean? When is something actually done? These questions could once be deferred to culture. Now they must be encoded.</p><p>This does not slow teams down. It allows them to move at speed without tearing themselves apart.</p><p>Policy-as-code, security-aware workflows, and default auditability are not bureaucratic overhead. They are the conditions under which autonomy becomes sustainable. Governance shifts left — not to constrain creativity, but to make high-velocity execution survivable.</p><h3>The Emergence of Agent-Native Roles</h3><p>As workflows become the locus of leverage, roles change.</p><p>Senior engineers increasingly shape decision systems rather than writing code. New responsibilities emerge around workflow design, agent reliability, and contextual integrity. Impact is measured not by how much code someone produces, but by how much unnecessary work disappears because the system learned.</p><p>Career progression follows leverage over how work happens, not proximity to the keyboard.</p><p>This is not a loss of craftsmanship. It is its evolution.</p><h3>Teams as Learning Systems</h3><p>The endgame is not faster delivery. It is faster learning.</p><p>Agents make experimentation cheap. Failures become data. Workflows can evolve weekly. Insights can be encoded directly into the system that executes them. Over time, teams stop shipping software as isolated artifacts and start building systems that continuously redesign themselves.</p><p>At that point, competitive advantage is no longer about talent density or tooling. It is about the rate at which an organization can turn experience into structure.</p><p>The teams that win will not be the ones with the best agents.<br>They will be the ones that learned how to think together — at scale.</p><p>Autonomous agents do not make software teams faster by default.<br>They make whatever structure already exists more visible — and more consequential.</p><p>Teams that rely on implicit agreements, informal ownership, and social negotiation will find those patterns amplified until they no longer hold. Teams that externalize decisions, encode constraints, and evolve their workflows deliberately will gain leverage that looks, from the outside, like speed.</p><p>The unit of optimization is shifting again.<br>Not from developers to tools.<br>Not from humans to machines.</p><p>But from teams to systems that learn.</p><p>Software will still be written.<br>But the organizations that matter will be the ones that learned how to redesign how work happens , at scale and before their systems forced the issue.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0b3ab7d5a38f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How AI is Reshaping DevOps]]></title>
            <link>https://sventorben.medium.com/how-ai-is-reshaping-devops-422fe0255700?source=rss-1a1f818fe03d------2</link>
            <guid isPermaLink="false">https://medium.com/p/422fe0255700</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Sven-Torben Janus]]></dc:creator>
            <pubDate>Sun, 09 Feb 2025 06:31:43 GMT</pubDate>
            <atom:updated>2025-02-09T06:31:43.707Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>How AI is Reshaping DevOps: A Natural Evolution of Platform Engineering</strong></h3><p>After diving into the impact of Platform Engineering <a href="https://sventorben.medium.com/how-platform-engineering-is-transforming-devops-lessons-from-the-dora-2024-report-c4967f5bb593">in my last article</a>, it became clear that we’re seeing a broader transformation in DevOps. Platform engineering has laid the groundwork for more efficient, scalable, and developer-friendly workflows. But what’s next? Enter AI — a force that is rapidly reshaping how we think about software delivery, developer productivity, and automation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*339tn38Njpr4pJ6C" /></figure><h3>AI: The Logical Next Step in DevOps Maturity</h3><p>Just as platform engineering gave developers the autonomy to move faster by removing friction, AI is now taking it one step further. With AI-powered coding assistants, automated workflows, and intelligent debugging tools, developers are seeing unprecedented gains in productivity. According to the <a href="https://cloud.google.com/devops/state-of-devops?hl=en">DORA 2024 report</a>, 75% of developers report increased productivity when using AI, and 10% say the impact is extreme.</p><p>Beyond just efficiency, AI is helping teams streamline documentation, enhance code quality, and even make software development more accessible. The same way internal platforms created <strong>golden paths </strong>for engineers, AI is now building <strong>smarter paths</strong>, reducing toil, and accelerating decision-making. For example, 67% of developers stated that AI improved their ability to write code, while 74.9% use AI to summarize information, making knowledge more accessible and reducing cognitive load.</p><h3>Challenges: Where AI Meets Reality</h3><p>Of course, no transformation is without its challenges. The DORA report highlights some surprising downsides of AI adoption in DevOps. While AI speeds up individual developer productivity, it negatively impacts software delivery performance. Throughput drops by 1.5%, and delivery stability takes a larger hit at 7.2%. The reason? <strong>AI can generate code faster, but larger and more frequent changes introduce complexity, making releases harder to manage.</strong> This correlates with findings that AI increases rework and change failure rates, meaning teams may be moving faster but at the cost of stability.</p><p><strong>Trust is also a growing concern.</strong> Despite AI’s wide adoption, 39% of developers say they don’t fully trust AI-generated code. This skepticism is understandable — many AI-generated solutions require fine-tuning or additional oversight to ensure they align with best practices. The report also found that <strong>developers are spending less time on valuable work than expected</strong>, suggesting that automation hasn’t fully eliminated manual effort but instead shifted priorities.</p><p>Another crucial finding is that AI does not inherently improve software delivery outcomes<strong>.</strong> Even though it helps with documentation, review processes, and task automation, its effects on product performance remain unclear. Organizations expecting AI to automatically lead to better software quality need to rethink their strategies — AI is a tool, not a shortcut.</p><h3>Bridging the Gap: AI and Platform Engineering Together</h3><p>Rather than seeing AI and platform engineering as separate forces, it’s worth considering how they can complement each other. AI-driven automation can make internal developer platforms even more powerful by enhancing self-service capabilities, automating compliance and security checks, and optimizing infrastructure usage in real-time. For example, AI can predict deployment risks based on past failure patterns and suggest corrective actions before pushing to production.</p><p>At the same time, <strong>platform engineering can act as a stabilizing force</strong>, ensuring that AI doesn’t introduce chaos into workflows. Guardrails, structured release processes, and smart feedback loops can help mitigate AI’s negative impact on stability while maximizing its benefits. By integrating AI into a well-structured platform, organizations can create a hybrid approach that leverages automation while maintaining control over delivery processes.</p><h3>The Future of DevOps: Smarter, Not Just Faster</h3><p>The DORA 2024 report makes one thing clear: AI is here to stay, but its impact is still unfolding<strong>.</strong> However, its success in DevOps will depend on how thoughtfully we integrate it. AI should not be about chasing speed at the expense of reliability. Instead, it should be about making <strong>software delivery smarter</strong> — optimizing workflows, reducing cognitive load, and empowering teams with the right tools at the right time.</p><p>Much like platform engineering, AI adoption requires an iterative approach. Early excitement must give way to mature, measured implementation that aligns with DevOps best practices. Organizations that figure out how to balance these forces will be the ones that truly unlock AI’s potential in software development. For instance, teams that integrate AI within a structured CI/CD pipeline — rather than using it in an ad-hoc manner — may see better performance and lower error rates.</p><p>As AI continues to evolve, so must our strategies. The question isn’t whether AI will be part of DevOps — it’s how we ensure it delivers real, sustainable value in the long run. Organizations that take a strategic, measured approach to AI adoption will be the ones that truly benefit from its potential, rather than being caught in the hype cycle. The future of DevOps isn’t just about speed; it’s about intelligence, adaptability, and sustainable innovation.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=422fe0255700" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Platform Engineering is Transforming DevOps: Lessons from the DORA 2024 Report]]></title>
            <link>https://sventorben.medium.com/how-platform-engineering-is-transforming-devops-lessons-from-the-dora-2024-report-c4967f5bb593?source=rss-1a1f818fe03d------2</link>
            <guid isPermaLink="false">https://medium.com/p/c4967f5bb593</guid>
            <category><![CDATA[data-platform-engineering]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[teams-and-teamwork]]></category>
            <dc:creator><![CDATA[Sven-Torben Janus]]></dc:creator>
            <pubDate>Sat, 01 Feb 2025 12:08:58 GMT</pubDate>
            <atom:updated>2025-02-01T12:08:58.216Z</atom:updated>
            <content:encoded><![CDATA[<p>I recently came across the <a href="https://cloud.google.com/devops/state-of-devops">DORA Accelerate State of DevOps 2024 report</a>, and it reinforced something I’ve been thinking about for a while: platform engineering is not just a buzzword — it’s a game-changer. But like any transformation, it comes with its share of challenges. Here’s my take on the report’s findings and what they mean for DevOps teams.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*zHS58FjPTEl_6yS_.jpg" /></figure><h3>The Promise of Platform Engineering</h3><p>At its core, platform engineering is about enabling developers to focus on what they do best: creating business value through code. By creating internal platforms that streamline tasks like application provisioning, testing, and deployment, platform teams reduce the friction that slows down software delivery.</p><p>The benefits are clear. Developers who use internal platforms report noticeable gains in productivity because self-service workflows allow them to work independently, eliminating long wait times. Team collaboration also improves significantly, as platforms create standardized workflows that help engineers work more efficiently. At an organizational level, platform engineering supports faster delivery and better alignment with business goals, ultimately leading to better outcomes across the board.</p><h3>The Challenges Platforms Face</h3><p>While the potential of platform engineering is evident, the DORA 2024 report also highlights some unexpected downsides. One of the most surprising findings is a decline in throughput, as organizations experience slower software delivery due to the added complexity of platform systems. The very mechanisms meant to streamline workflows can sometimes introduce unnecessary delays through rigid structures and excessive handoffs.</p><p>Change stability also takes a hit, with platforms introducing new dependencies that teams must navigate. When platforms aren’t flexible enough to accommodate specific team needs, they can create more problems than they solve. Additionally, the J-curve effect is a recurring theme — many teams see initial gains, only to hit a plateau or even regress before stabilizing. This is a natural part of the process, but it requires patience and ongoing iteration to sustain long-term success.</p><h3>Key Lessons for Platform Success</h3><p>To fully realize the benefits of platform engineering, organizations need to find the right balance between structure and flexibility. A platform should be designed to reduce complexity rather than add to it, avoiding unnecessary bottlenecks and streamlining essential processes. Instead of forcing developers into a rigid workflow, platforms should allow for adaptability, giving teams the freedom to bypass constraints when needed.</p><p>Feedback from developers is crucial. A platform is only as strong as its adoption, and teams need to feel that it actually helps them do their work rather than slowing them down. Collecting input continuously ensures that the platform evolves to meet real-world needs rather than theoretical ones. Most importantly, platforms should foster independence. The best platforms enable developers to own their workflows without excessive reliance on external support teams.</p><h3>The Road Ahead for Platform Engineering</h3><p>The DORA 2024 report underscores that platform engineering is not a one-size-fits-all solution, but when implemented thoughtfully, it becomes a powerful enabler of high-performing teams. The key is to treat platform engineering as an evolving practice rather than a fixed framework. Early wins are just the beginning — sustained success depends on iterative refinement and a commitment to user-centric design.</p><p>Organizations that invest in well-structured, adaptable platforms will gain a serious competitive advantage. But as the DORA report reminds us, technology alone is not enough. The real success of platform engineering lies in how we build and adapt it to empower teams, making their work easier, faster, and more effective.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c4967f5bb593" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Beyond Perimeters: Zero Trust as the Foundation for Resilient KRITIS Systems]]></title>
            <link>https://sventorben.medium.com/beyond-perimeters-zero-trust-as-the-foundation-for-resilient-kritis-systems-efd59aa56af4?source=rss-1a1f818fe03d------2</link>
            <guid isPermaLink="false">https://medium.com/p/efd59aa56af4</guid>
            <category><![CDATA[security]]></category>
            <category><![CDATA[zero-trust]]></category>
            <category><![CDATA[kritis]]></category>
            <dc:creator><![CDATA[Sven-Torben Janus]]></dc:creator>
            <pubDate>Sat, 01 Feb 2025 11:46:59 GMT</pubDate>
            <atom:updated>2025-02-01T11:46:59.995Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*EdBlusrvXaQCwFTe" /></figure><p>For software and systems architects working in critical infrastructure (KRITIS), the increasing digitization and interconnection of systems have brought undeniable operational benefits — but also escalating risks. Systems once isolated are now part of complex, hybrid architectures that stretch across on-premises, cloud, and edge environments. Traditional security models, which rely on hard perimeters, struggle to account for this complexity, leaving critical systems vulnerable to modern threats.</p><p>Zero Trust Architecture (ZTA) reframes this challenge as a design opportunity: it assumes breaches will happen and emphasizes verification, segmentation, and identity as core principles of system resilience. For architects, this means embedding Zero Trust principles into the design and development of systems from the outset, ensuring that every user, device, or service interacting with critical systems is explicitly verified and continuously monitored.</p><p>This article explores how software and systems architects can adopt Zero Trust as part of their broader strategy for building secure, reliable, and adaptable KRITIS environments.</p><h3>Zero Trust Principles and Their Application in KRITIS</h3><p>At its core, Zero Trust is a design philosophy, not just a security strategy. It aligns naturally with modern architectural patterns such as microservices, API-driven systems, and hybrid infrastructure. Instead of assuming trust based on network boundaries, Zero Trust enforces explicit verification at every layer, ensuring that systems can operate securely regardless of their environment.</p><p>For KRITIS, this means building systems where access is always validated, using principles like:</p><ul><li>Identity-Centric Verification: Every user, device, and service must authenticate and prove its legitimacy.</li><li>Least Privilege: Access to resources is tightly scoped and context-aware.</li><li>Continuous Verification: Trust is reevaluated dynamically with every request, leveraging real-time data such as device posture and user behavior.</li></ul><p>Software and systems architects play a central role in embedding these principles into design decisions. By adopting Zero Trust, systems become less reliant on traditional boundaries, reducing the attack surface while improving adaptability in modern environments.</p><h3>Implementing Zero Trust in KRITIS Environments</h3><p>Implementing Zero Trust in KRITIS environments starts with a clear understanding of the system architecture. Architects must first map out assets, access points, and data flows to identify critical systems and potential vulnerabilities. This foundational step informs decisions about where to apply authentication, authorization, and segmentation.</p><p>A central identity layer is essential for enabling Zero Trust principles. By adopting federated identity systems, architects can ensure seamless authentication across on-premises and cloud environments while enforcing multi-factor authentication (MFA) and contextual access policies.</p><p>Network segmentation plays a crucial role in limiting lateral movement. Breaking down networks into smaller, isolated segments prevents attackers from accessing critical systems even if one area is compromised. For hybrid systems, this segmentation must extend to cloud services and APIs, with policies consistently enforced.</p><p>Finally, continuous monitoring and telemetry provide visibility into system activity. By embedding logging and anomaly detection into the architecture, architects can ensure that suspicious behavior is detected and mitigated before it becomes a threat.</p><h3>Addressing KRITIS-Specific Challenges</h3><p>The implementation of Zero Trust in critical infrastructure (KRITIS) brings with it several unique challenges that software and systems architects must address. These include legacy systems that cannot support modern security standards, the need for uninterrupted operations, and strict regulatory compliance.</p><p>Many KRITIS environments still rely on legacy systems that were not designed with today’s cybersecurity threats in mind. These systems often lack support for modern authentication methods or encryption, yet they remain operationally essential. Instead of attempting disruptive replacements, architects can integrate secure proxies or API gateways that wrap these systems with modern security layers, such as token-based authentication or TLS encryption. This approach ensures Zero Trust principles are applied without overhauling the entire architecture.</p><p>Another significant challenge is the demand for operational continuity. Systems that provide essential services cannot afford downtime. Implementing Zero Trust in such environments requires a phased rollout: architects should begin with less critical systems to validate changes, then gradually extend the model to production environments. Redundancy and failover mechanisms must be built into the design to avoid disruptions during deployment.</p><p>Finally, architects must align Zero Trust initiatives with regulatory requirements such as NIS2 or ISO/IEC 27001. These standards can serve as both guidelines and constraints, helping teams prioritize measures like continuous logging, traceability, and auditability. Proper documentation ensures compliance without compromising architectural flexibility.</p><h3>Building a Phased Implementation Strategy</h3><p>A successful Zero Trust implementation in KRITIS environments depends on careful planning and a phased, iterative approach. Attempting a “big bang” rollout risks disrupting operations and overwhelming technical teams. Instead, architects should design a gradual implementation strategy that prioritizes critical assets and uses early successes to build confidence across the organization.</p><p>The first phase involves assessing the current state of systems and identifying vulnerabilities. Architects must perform a thorough inventory of assets, users, and data flows to understand where Zero Trust principles will have the greatest impact. From there, pilot projects can be launched within isolated environments — such as a single network segment or non-critical business unit — allowing teams to validate new access controls, monitoring tools, and identity systems in a controlled setting.</p><p>Lessons learned during these pilot phases inform the broader rollout. Once proven effective, Zero Trust measures can be scaled systematically across other parts of the environment. This step-by-step approach ensures minimal disruption while providing tangible improvements in security and system resilience.</p><p>Architects must also address organizational readiness. Training sessions, technical workshops, and clear communication help align stakeholders with the project’s goals. By fostering cross-team collaboration and demonstrating value through incremental progress, resistance to change is reduced, and momentum is maintained.</p><h3>Overcoming Organizational Resistance</h3><p>Resistance to change is a natural part of any transformative project, especially in environments as sensitive as KRITIS. Introducing Zero Trust requires rethinking long-established systems, workflows, and responsibilities. Architects can mitigate this resistance by fostering understanding, aligning technical goals with operational priorities, and demonstrating early wins.</p><p>Clear, practical communication is key. Teams need to understand how Zero Trust strengthens resilience without introducing unnecessary overhead. Early pilot projects can serve as proofs of concept, showing how systems can become more secure and adaptable without sacrificing operational efficiency.</p><p>Collaboration between security, IT, and operational teams is equally vital. By involving all stakeholders early and encouraging cross-functional cooperation, architects can ensure that Zero Trust measures address both technical and business concerns.</p><h3>Conclusion: Building Resilient Systems with Zero Trust</h3><p>For software and systems architects working in KRITIS environments, Zero Trust represents more than a security strategy — it is a foundational principle for system resilience. As infrastructures grow more complex, interconnected, and reliant on hybrid deployments, the traditional security model of perimeter defenses becomes untenable. By embracing Zero Trust, architects have the opportunity to rethink how systems are designed, ensuring security, flexibility, and reliability are woven into the architecture itself.</p><p>Zero Trust principles — identity-centric access, least privilege enforcement, segmentation, and continuous verification — align closely with modern architectural patterns. For microservices, APIs, and distributed systems, these principles are natural extensions of existing design goals: building systems that are modular, adaptable, and capable of reducing the blast radius of potential failures. Implementing Zero Trust is not a one-time project but an iterative process. Each phase of implementation offers architects a chance to validate their assumptions, refine policies, and integrate lessons learned back into the system design.</p><p>While challenges such as legacy systems, operational demands, and regulatory compliance persist, these are not barriers but design constraints. Thoughtful planning, incremental implementation, and collaboration across security and operations ensure that Zero Trust becomes a practical part of the organization’s architecture.</p><p>Ultimately, the adoption of Zero Trust enables KRITIS organizations to address today’s security challenges while preparing for tomorrow’s uncertainties. The result is systems that are not only more secure but also more resilient — capable of sustaining critical services even in the face of disruption.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=efd59aa56af4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Reduce Cognitive Load in the Digital Age]]></title>
            <link>https://sventorben.medium.com/reduce-cognitive-load-in-the-digital-age-3438ec6f282d?source=rss-1a1f818fe03d------2</link>
            <guid isPermaLink="false">https://medium.com/p/3438ec6f282d</guid>
            <category><![CDATA[shift-left-security]]></category>
            <category><![CDATA[cognitive-load]]></category>
            <category><![CDATA[sociotechnical]]></category>
            <category><![CDATA[shift-left-testing]]></category>
            <category><![CDATA[cognitive-load-theory]]></category>
            <dc:creator><![CDATA[Sven-Torben Janus]]></dc:creator>
            <pubDate>Fri, 09 Feb 2024 17:24:45 GMT</pubDate>
            <atom:updated>2024-02-09T17:24:45.030Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g2WaIaUgK5Qe1-kY7dmQLw.png" /></figure><p>In the swiftly evolving landscape of digital transformation, a crucial yet often overlooked element demands our attention: cognitive load management. As technology leaders, we’re constantly seeking ways to push the boundaries of innovation, streamline processes, and enhance productivity. Yet, in our quest for advancement, we must pause and consider the impact of cognitive overload on our teams and the creative process itself.</p><h3>The Double-Edged Sword of “Shift Left”</h3><p>The “Shift Left” strategy, aimed at integrating considerations such as security, operations, compliance, and quality assurance early in the development cycle, has become a mantra within software development circles. While its intentions are noble, aiming to enhance product quality and security, it inadvertently contributes to a significant increase in cognitive load for development teams. This escalation not only challenges the mental bandwidth of our teams but also poses a risk to the nurturing of innovation. It is time we ask ourselves: Are we truly facilitating progress, or are we inadvertently hindering our teams’ potential?</p><h3>Unpacking Cognitive Load</h3><p>Cognitive load refers to the total amount of mental effort being used in the working memory. In the context of digital transformation, it encapsulates the mental energy required to navigate complex systems, processes, and the constant influx of information. By recognizing and addressing cognitive overload, we can create an environment that fosters clarity, creativity, and innovation. The question then becomes: How can we effectively manage cognitive load to unlock our teams’ full potential again?</p><h3>Strategies for Managing Cognitive Load</h3><p>It is essential to explore strategic approaches that can alleviate the mental burden on our teams, enhancing their capacity for innovation and productivity. Here are some effective strategies:</p><p>Intuitive Technology Selection: Choose technologies that prioritize user-friendliness and intuitive design. Tools that are complex and difficult to navigate can significantly increase cognitive load, detracting from the overall productivity and creativity of the team.</p><p>Promoting a Culture of Continuous Learning: Foster an environment where continuous learning is not just encouraged but integrated into the daily workflow. Providing team members with the resources and opportunities to learn and adapt reduces the cognitive load associated with mastering new tools and technologies.</p><p>Avoiding Over-Simplification and Abstraction: While simplification and abstraction can be beneficial, overly simplistic and abstracted solutions may omit essential information or functionality, inadvertently increasing cognitive load. Striking the right balance is key to ensuring that systems are both efficient and comprehensive.</p><h3>Lighten the Load, Ignite Innovation</h3><p>Managing cognitive load is not just about enhancing efficiency; it’s about creating an environment where creativity and innovation can flourish. By reevaluating our approaches to technology selection and team development, we can mitigate the adverse effects of cognitive overload and pave the way for groundbreaking innovation.</p><p>I invite you to share your thoughts and experiences in managing cognitive load within your organizations. How have you tackled the challenges associated with “Shift Left”? What strategies have you found most effective in reducing cognitive overload?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3438ec6f282d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Undervaluation of Code Quality and its Impact on Business Success]]></title>
            <link>https://sventorben.medium.com/the-undervaluation-of-code-quality-and-its-impact-on-business-success-cc3bcaaa42b8?source=rss-1a1f818fe03d------2</link>
            <guid isPermaLink="false">https://medium.com/p/cc3bcaaa42b8</guid>
            <category><![CDATA[sociotechnical]]></category>
            <category><![CDATA[technical-debt]]></category>
            <category><![CDATA[code-quality]]></category>
            <category><![CDATA[business-success]]></category>
            <category><![CDATA[code-improvement]]></category>
            <dc:creator><![CDATA[Sven-Torben Janus]]></dc:creator>
            <pubDate>Wed, 01 Nov 2023 06:31:43 GMT</pubDate>
            <atom:updated>2023-11-01T13:27:09.904Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Unlocking the True Potential of Code Quality in a Fast-Paced World</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a_c3tpH9aSCb3CcffxfNTA.jpeg" /></figure><p>Fresh from restorative holidays, this article delves into my personal reflections on the pivotal role of code quality in the fast-paced world of software development. It is not a scholarly thesis, but rather an exploration of often overlooked aspects of code quality and its impact on our ever-evolving industry. While some sections reference scientific research, my primary aim is to share the thoughts that emerged during my short break.</p><p>In the first section, we will unravel the intricate world of code quality and its profound influence on business success.</p><h3>Speed vs. Quality — The Conundrum</h3><h4>The Need for Speed</h4><p>In today’s fast-paced business environment, speed is often considered the holy grail of success. Organizations strive to bring products and services to market as quickly as possible to gain a competitive advantage. The logic is simple: the faster you release, the faster you can iterate, adapt to customer feedback, and outmaneuver your competitors.</p><p>While speed is undeniably important, there is a persistent misconception that prioritizing speed requires a trade-off with code quality. This fallacy often leads businesses to compromise on code quality in the pursuit of rapid development. In reality, this trade-off is not as necessary as it might seem.</p><h4>The Fallacy of Trade-Offs</h4><p>The “speed vs. quality” conundrum is deeply rooted in many business cultures. The prevailing belief is that to deliver faster, corners must be cut, and code quality sacrificed. However, this view is a simplified and outdated understanding of software engineering.</p><p>Empirical data challenges this perspective. Studies have shown that a myopic focus on speed at the expense of code quality can lead to a host of problems:</p><ol><li><strong>Increased Technical Debt</strong>: Rushing through development without considering code quality can result in what is known as “technical debt.” Technical debt represents the compromises made during development, such as taking shortcuts or forgoing best practices, which accumulate over time. Just as financial debt accrues interest, technical debt accrues “interest” in the form of increased maintenance costs and reduced development speed.</li><li><strong>Higher Defect Rates:</strong> Poor code quality leads to more defects. These defects can have cascading effects on development, leading to delayed releases, increased customer support efforts, and up to potential damage to your brand’s reputation.</li><li><strong>Stifled Innovation:</strong> A focus on speed at the cost of code quality can stifle innovation within your development teams. When engineers are constantly dealing with technical debt and firefighting, they have less time and energy for creative problem-solving and innovation.</li><li><strong>Higher Long-Term Costs:</strong> Short-term gains in speed can result in higher long-term costs. The technical debt accrued during rapid development can make future changes and enhancements more time-consuming and expensive.</li></ol><h4>Data Challenges Conventional Wisdom</h4><p>What makes this trade-off between speed and quality so problematic is that it is based on an outdated understanding of software engineering. Modern development practices, such as Agility and DevOps, emphasize the need for both — speed and quality. In fact, data consistently demonstrates that organizations that prioritize code quality not only experience fewer defects but also enjoy faster, more efficient development processes in the long run.</p><p>Empirical evidence shows that code quality is not a hindrance to speed, but rather a catalyst for it. Quality code streamlines development, reduces defects, and enhances team productivity, all of which contribute to faster product delivery.</p><h4>Navigating the Speed-Quality Conundrum</h4><p>Subsequently, we will delve deeper into the empirical data that challenges conventional wisdom. We will explore the social and psychological aspects of code quality, its impact on team dynamics, and the practical tools and methods available for managing technical debt effectively.</p><p>It is time to debunk the myth of the “speed vs. quality” trade-off!<br>By the end of this article, you will have a comprehensive understanding of how to prioritize code quality without sacrificing speed, unlocking the true potential of your software engineering process.</p><h3>The Empirical Data</h3><p>In an era where data-driven decision-making reigns supreme, it is imperative to ground our understanding of code quality in empirical data. It is this data that validates the importance of high code quality, especially in a world where businesses are sprinting towards digital transformation.</p><p>One of the most significant research contributions to the field of code quality is the work of Adam Tornhill, which challenges the notion that high-quality code is merely a matter of craftsmanship. Adam Tornhill’s research provides critical insights into the measurable business impact of code quality.</p><h4>The Measurable Business Impact of Code Quality</h4><p>Adam Tornhill’s and Markus Borg’s research, notably the <a href="https://doi.org/10.48550/arXiv.2203.04374">“Code Red” paper</a>, delves into the profound effects of code quality on various aspects of software engineering and, consequently, business outcomes. It shatters the myth that code quality is merely a technical concern.</p><p>According to their research:</p><ul><li><strong>Red Code vs. Healthy Code:</strong> The research found that code quality has a dramatic impact on the number of defects. On average, “red code” (poor-quality code) has 15 times more defects than a healthy codebase. This high defect density can lead to a substandard product experience.</li><li><strong>Waste in Red Code:</strong> Implementing changes in red code takes more than twice as long as making corresponding changes in green code (healthy code). This substantial waste in time and resources is a clear indication that code quality directly affects the speed of development.</li><li><strong>Unpredictability in Low-Quality Code:</strong> Perhaps the most crucial finding is the unpredictability associated with low-quality code. Adding a feature to healthy code appears to be a predictable process, whereas unhealthy red code exhibits significant variation. Work in such code can take up to nine times longer, creating uncertainty for the organization.</li></ul><p>The implications are profound. Uncertainty in development timelines, coupled with increased defect rates, can impact not only project delivery but also customer satisfaction and ultimately the bottom line.</p><h4>Code Quality and Speed are Related</h4><p>Contrary to a common misconception in the software industry that speed and quality are mutually exclusive, Adam Tornhill’s research underscores the idea that there is no such trade-off. Instead, the data reveals that high code quality is a prerequisite for achieving speed.</p><p>Increased throughput is largely an effect of reduced uncertainty. Clean and well-maintained code has fewer surprises and poses less risk of causing unexpected problems. It also reflects a strong engineering culture, likely supported by other essential practices within the organization.</p><p>These findings align with research conducted by the <a href="https://dora.dev/">DevOps Research and Assessment (DORA)</a> group, which suggests that shorter deployment cycle times lead to fewer production failures. In essence, <strong>the relationship between code quality and speed</strong> is not a trade-off; it <strong>is a symbiotic one</strong>.</p><p>As we proceed, we will explore the various facets of code quality and its direct impact on business outcomes, from time-to-market and product quality to the competitiveness of your organization.</p><h3>The Sociotechnical Aspect of Code Quality</h3><p>Code quality is not just about lines of code or technical best practices; it is fundamentally tied to the people who create, maintain, and use the code. The “sociotechnical” nature of software engineering implies that the human aspect plays a significant role in code quality.</p><p>Successful software engineering requires that you keep code and people in balance so that one supports the other. This is a complex challenge, as maintaining a holistic view of a large codebase is virtually impossible. Adding to the complexity, the people side of code is even more opaque; a piece of code does not reveal anything about its socio-technical context.</p><p>However, data tells us that code quality has a tangible impact on the efficiency and effectiveness of software engineering. Now, let us delve into the sociotechnical aspects that reveal how the quality of code influences not only the technical aspects but also the social and psychological dynamics within development teams.</p><h4>Code Health and Team Morale</h4><p>From my experience, one of the most intriguing aspects of code quality is its impact on team morale and dynamics. Healthy codebases tend to foster a more positive working environment. Developers are more engaged, less stressed, and more satisfied with their work when they are dealing with code that follows best practices and is easy to understand.</p><p>In contrast, when developers are constantly grappling with technical debt and poor code quality, it can lead to feelings of frustration and disillusionment. High turnover rates are common in teams dealing with persistent code quality issues, which, in turn, affect the continuity and productivity of development projects.</p><h4>Collaboration and Innovation</h4><p>Code quality is not just a matter of producing bug-free software; it also shapes the collaborative culture within your development teams. Healthy codebases encourage collaboration, knowledge sharing, and collective problem-solving. Developers in such environments are more likely to work together, share insights, and collectively drive innovation.</p><p>On the flip side, poor code quality can be a barrier to collaboration. It often leads to finger-pointing, blame-shifting, and a lack of trust within teams. When developers spend more time fixing issues and dealing with technical debt, they have less time for creative problem-solving and innovation.</p><h4>The Sociotechnical Conundrum</h4><p>The sociotechnical conundrum is that poor code quality not only affects the technical aspects of development but also creates ripple effects throughout the organization. It impacts the morale of your development teams, hinders collaboration, and can stifle innovation.</p><p>This is where Adam Tornhill’s research ties into the sociotechnical aspect. Tornhill’s insights remind us that code quality is not just about bug counts and development speed; it is about fostering a work environment that nurtures creativity, encourages collaboration, and sustains a motivated and productive team.</p><h3>Behavioral Code Analysis: A New Perspective</h3><p>Fortunately, a set of innovative techniques known as behavioral code analysis has emerged to address this challenge. This approach combines code-level metrics with easily accessible behavioral data on how teams interact within the code. With these techniques, we can unravel the intricate dance between code and people, shedding light on the often opaque social and technical dynamics at play.</p><p>Behavioral code analysis empowers organizations to:</p><ul><li><strong>Identify Architectural Coordination Bottlenecks:</strong> By analyzing team interactions within the code, organizations can pinpoint coordination bottlenecks and understand the technical root causes that lead to them. This knowledge helps in optimizing the architectural design and enhancing collaboration among teams.</li><li><strong>Visualize Implicit Dependencies:</strong> The analysis reveals implicit dependencies between teams, often hidden beneath the surface. Armed with this information, organizations can take strategic steps to decouple teams, reducing the risk of interdependence and bottlenecks.</li><li><strong>Discover Knowledge Risks:</strong> Behavioral analysis allows for the measurement of the “Bus Factor/Truck Number” which quantifies the risk associated with key personnel holding unique knowledge. By identifying and mitigating these knowledge risks, organizations can ensure business continuity.</li><li><strong>Communicate Scaling Risks:</strong> By understanding how code quality impacts development speed and team morale, organizations can communicate the inherent risks of scaling, as described in <a href="https://en.wikipedia.org/wiki/Brooks%27s_law">Brooks’s Law</a>. These insights allow for more informed decision-making and risk mitigation strategies.</li><li><strong>Beyond Technical Impact:</strong> Behavioral code analysis goes beyond technical impact to reveal how bad code can cause unhappiness, low morale, and increased attrition among development teams. This understanding underscores the importance of maintaining code quality not just for technical reasons but for the well-being of your teams.</li></ul><p>For senior developers, software architects, or technical leads, this perspective can change how you view code quality. The techniques discussed here are available in existing tools, the most famous probably CodeScene, which can be put to use immediately. They emphasize that technical decisions are never merely technical; they have profound socio-technical implications. By remedying and preventing socio-technical “smells,” you can stay a step ahead in your software engineering endeavors.</p><p>In the following sections, we will explore methods which can help in managing technical debt and improving code quality. These methods do not just optimize code but also promote a healthier sociotechnical ecosystem within your organization.</p><h3>Managing Technical Debt — A Holistic Approach</h3><h4>Navigating the Complex Terrain of Technical Debt</h4><p>As we have learned, technical debt is an unavoidable reality in software development. It involves making trade-offs to meet short-term goals, often at the expense of long-term code quality. The accumulation of technical debt can lead to increased costs, reduced productivity, and delayed project delivery.</p><p>Recognizing the existence of technical debt is the first step. However, effectively managing it is essential for maintaining code quality and ensuring the sustainability of your software projects. Let us explore a holistic approach to managing technical debt, irrespective of the specific tools or techniques used.</p><h4>The Power of Holistic Technical Debt Management</h4><p>Effective technical debt management involves considering both the technical and sociotechnical aspects of software development. It acknowledges that code quality is not solely a technical endeavor but a multifaceted challenge that impacts both the code itself and the people who create and interact with it.</p><h4>Technical Debt Metrics</h4><p>To manage technical debt effectively, start with an assessment of your codebase’s health. Look beyond traditional code quality measurements and delve into metrics that encompass behavioral patterns and team interactions. By examining these metrics, you can gain a deep understanding of the health of your code and identify areas that need improvement.</p><h4>Identifying Critical Areas</h4><p>Every codebase has hotspots — sections of code that accumulate a significant amount of technical debt and are subject to frequent modifications. Identifying these hotspots is crucial. They represent areas where the code’s quality may be compromised, and the potential for defects and development challenges is high.</p><h4>Prioritizing Technical Debt Reduction</h4><p>Quantifying technical debt is essential, but equally important is understanding where to focus your efforts. Prioritize areas that will yield the most significant improvements in code quality and development speed. Allocate resources efficiently to address these high-impact areas and reduce the associated technical debt.</p><h4>Mitigating Risk</h4><p>Effective technical debt management is also about mitigating risks associated with knowledge concentration and potential attrition. When critical knowledge about specific parts of your codebase is held by only a few individuals, the organization is at risk if they leave. By identifying and addressing these knowledge risks, you can ensure business continuity.</p><h4>Code Quality Improvement</h4><p>Holistic technical debt management does not stop at identifying issues; it also provides actionable insights and recommendations for improving code quality. These may include refactoring suggestions and best practices to enhance code maintainability.</p><h4>The Sociotechnical Perspective</h4><p>Remember, the management of technical debt is a sociotechnical endeavor. It involves understanding how the quality of your code influences your development teams’ morale and collaboration. Neglecting the sociotechnical aspects can lead to high turnover rates and strained development teams, ultimately impacting your projects and people.</p><h4>In Summary</h4><p>Navigating the complex terrain of technical debt, it is important to embrace a holistic approach to management. The specific tools and techniques may vary, but the principles remain the same: prioritize code quality, balance the technical and sociotechnical aspects, and make informed decisions to reduce technical debt’s impact on your software projects.</p><p>By adopting a holistic perspective, you will be better equipped to enhance code quality, drive project success, and foster a culture of continuous improvement within your organization.</p><h3>Code Quality as a Competitive Advantage</h3><h4>Code Quality: A Catalyst for Success</h4><p>So far, we have embarked on a journey to explore the undervaluation of code quality in many modern businesses. We have navigated through the trade-off myth between speed and quality, studied empirical data, uncovered the sociotechnical aspects of code quality, and discussed effective methods for managing technical debt, irrespective of specific tools or techniques.</p><p>The central message that has emerged from our exploration is clear: code quality is not just a matter of pride in craftsmanship but a strategic business decision. It is not speed vs. quality; it is <strong><em>speed with quality</em></strong>.</p><h4>Code Quality’s Tangible Business Impact</h4><p>Empirical data, as presented before, illustrates the measurable business impact of code quality. High-quality code reduces defects, lowers maintenance costs, and results in faster development in the long run. It translates into improved customer satisfaction and a stronger competitive position. Code quality is not merely an abstract concept; it is a powerful driver of business success.</p><h4>The Sociotechnical Perspective</h4><p>We illuminated the sociotechnical dimension of code quality. It is not just about the technical aspect; it is about the people side of code. Healthy codebases foster a positive working environment, enhance collaboration, and promote innovation. Neglecting the sociotechnical aspects can lead to high turnover rates and strained development teams, which ultimately hinders your projects and your people.</p><h4>Holistic Technical Debt Management</h4><p>We detailed the value of holistic technical debt management. This approach encompasses technical and sociotechnical considerations and enables organizations to identify, prioritize, and mitigate technical debt. Effective management of technical debt is about more than tools; it is about optimizing the entire development process.</p><h3>Final Thoughts: Code Quality as a Competitive Advantage</h3><p>In conclusion, code quality is not a choice between speed and quality; it is a strategic partnership that unlocks the true potential of your software development. High-quality code is not just a technical achievement; it is a competitive advantage that propels your business forward.</p><p>As you reflect on the insights presented in this article, consider how you can implement these concepts in your organization. Recognize that code quality is not just a concern for developers but a vital aspect of your business strategy. Prioritizing code quality does not just lead to better code; it leads to a more efficient, agile, and ultimately, faster development process. It ensures that your teams are motivated, your customers are satisfied, and your organization remains competitive.</p><p>As you move forward, embrace the mantra: <strong>“Speed with Quality.”</strong> Embrace the principles that uphold this notion, and you will be on a path to not just meeting but exceeding your business objectives.</p><p>I hope this article has shed light on the undervaluation of code quality and has provided you with actionable insights on how to harness it for business success. Together, let us foster a culture of continuous improvement and set new standards for success in the ever-evolving world of technology. Your commitment to code quality will undoubtedly be a driving force behind your organization’s success.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cc3bcaaa42b8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Macroservices]]></title>
            <link>https://sventorben.medium.com/macroservices-f18d0c25d76d?source=rss-1a1f818fe03d------2</link>
            <guid isPermaLink="false">https://medium.com/p/f18d0c25d76d</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[cognitive-load]]></category>
            <category><![CDATA[macroservices]]></category>
            <category><![CDATA[sociotechnical-system]]></category>
            <category><![CDATA[complexity]]></category>
            <dc:creator><![CDATA[Sven-Torben Janus]]></dc:creator>
            <pubDate>Fri, 09 Apr 2021 12:36:22 GMT</pubDate>
            <atom:updated>2021-10-21T11:16:52.267Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rnCA81U6xGF_-UqC.jpg" /></figure><p>Microservices have been the major architectural trend in recent years. In <a href="https://www.gartner.com/en/documents/3988288/hype-cycle-for-application-architecture-and-development">Gartner’s Hypecycle 2020</a>, Microservices are “sliding into the truth”. Microapps are on the rise and more popular than ever. When it comes to application architecture it seems clear: smaller is better.<br>Although, since the term Macroservice has been <a href="http://highscalability.com/blog/2020/4/8/one-team-at-uber-is-moving-from-microservices-to-macroservic.html">circulating in social media</a>, considering larger units comes in vogue again.</p><h3>Smaller is better. But wait… is it?</h3><p><em>Micro</em>services, <em>nano</em>services, server<em>less</em>, <em>big</em> ball of mud — or is it <em>Macro</em>services? Well what now, small or large? At least one thing can be said with certainty: size seems to be decisive. Heuristics such as <a href="https://docs.aws.amazon.com/whitepapers/latest/introduction-devops-aws/two-pizza-teams.html">Amazon’s two pizza teams</a> aim precisely in this direction.</p><p>Let us zoom out a little of this picture. No matter how big the service is, it is part of a system of services. Many services interact with one another, perform tasks collectively, serve a larger purpose. Therefore, they need connections and dependencies to one another. They form a system. That is why architectural design has always been system design.<br>And with systems it is inherently always about delimitation: what is inside, what is outside? The size of a service results from this delimitation. The decisive question is what moves within the limits, what is in between and what is outside.</p><p>The answer to that question is always a tradeoff. The larger the services, the fewer relationships or connections are needed between them. And the smaller the services, the more connections are needed.</p><h3>Reliability</h3><p>Fewer large services result in fewer relationships. Several smaller services result in more relationships. And these connections create potential problem spots. Why?</p><p>Think about services as a static set of interacting features for a moment. Interactions can be expressed as relationships between features. Whether we build few large services or several small services, the number of inter-feature relationships is stable, because their inter-dependencies stay stable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iqZSCsdtK6m7jMl4Afm78w.png" /><figcaption>single vs. multi service feature set</figcaption></figure><p>However, when we divide services into smaller pieces, we generally tend to replace reliable connections with more unreliable connections. While in-memory communication can be seen as quite reliable, communication over networks may not. Networks do not always work reliably. Simply think of packet loss on the wire. In addition, we gain independent runtime, deployment and development life cycles of the individual services. This may lead to services becoming unavailable or incompatible throughout their lifecycle.</p><h3>Complexity</h3><p>While this may have benefits, the downside is that development, operation, and reasoning become more complex. To mitigate unreliability, a lot of work needs to be carried out to make such systems reliable and resilient again. Introducing tools such as service meshes, or implementing compensation strategies to mitigate unreliability make our systems technically more complex. Not to mention the cognitive (over)load that comes with it. The more unreliable relationships that need to be maintained between services, the greater the complexity of the system. Key is to find good balance between the complexity of the individual parts and that of the overall system.</p><h3>Organizational development</h3><p>The misinterpretation of the often-postulated team autonomy also increases the complexity of systems to some part. Autonomy certainly is a key factor if teams are expected to work efficiently and effectively. Nonetheless, we build systems! We must think in terms of systems.</p><p>By definition, a service or team without dependencies with others cannot be part of a system. Independent services are an illusion. Same is true for fully autonomous teams. There are no independent services/teams; there is always a relationship or dependency. Therefore, the goal cannot be to build autonomous services or set up fully autonomous teams, but to limit their (inter)dependencies or at least replace blocking ones with non-blocking ones.</p><p>Hence, software architecture also always means organizational development! As the saying goes:</p><blockquote>If you did not design the organization, you did not design the architecture.</blockquote><p>Socio-technical aspects of the system need serious consideration. To stay with the Amazon example: how big are the two pizzas? Mini pizzas, maxi pizzas or family pizzas? How many teams have ordered pizza? Do we need to coordinate delivery? Do we want to share or maybe order salat?</p><p>Teams, too, are limited in the amount of inherent, business, technical, and organizational complexity that they can handle. <a href="https://itrevolution.com/team-cognitive-load-team-topologies/">Team cognitive load</a> is a limiting factor that must not be underestimated.</p><h3>Heuristics</h3><p>Patterns and heuristics, such as <a href="https://github.com/ddd-crew/bounded-context-canvas">Bounded Contexts</a>, from <a href="https://www.dddheuristics.com/heuristics/">Domain Driven Design</a>, <a href="https://github.com/TeamTopologies/Independent-Service-Heuristics">independent service heuristics</a>, or <a href="https://teamtopologies.com/all-mini-books/mini-book-organization-dynamics-with-team-topologies">team-sized software</a>, may help here. However, cutting services is and always will be an individual approach towards the domain or business in focus. It is not easy to achieve — it is hard work. That is why it is often tempting to prefer simple heuristics such as “small size”, but in the end they do not lead to desired outcome.</p><p>Good services design is more than considering size but more about complexity and boundaries — at business, organizational, and technical level. We need to shift focus to sensible delimitation that creates balance between complexity within single services and complexity in the overall system. Aligning services not only to technical aspects, but foremost to business capabilities, user journeys, and organizational processes is key — combined with high-alignment and resilience.</p><p>An extended version of this article is available in German at <a href="https://www.informatik-aktuell.de/entwicklung/methoden/macroservices-nicht-kleine-teile-sondern-das-grosse-ganze.html">informatik-aktuell.de</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f18d0c25d76d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Domain Debt]]></title>
            <link>https://sventorben.medium.com/domain-debt-5bcf838041f7?source=rss-1a1f818fe03d------2</link>
            <guid isPermaLink="false">https://medium.com/p/5bcf838041f7</guid>
            <category><![CDATA[domain-driven-design]]></category>
            <category><![CDATA[technical-debt]]></category>
            <category><![CDATA[managing-technical-debt]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[code-review]]></category>
            <dc:creator><![CDATA[Sven-Torben Janus]]></dc:creator>
            <pubDate>Mon, 15 Mar 2021 07:03:29 GMT</pubDate>
            <atom:updated>2021-03-15T07:03:29.085Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*g-Wq_3UDHRuwCpxJ" /></figure><p>When working in some kind of technical role in IT, you may have heard about, experienced, identified, introduced, or hopefully reduced technical debt. In contrast, Domain Debt is seldom talked about. In this article, I compare the two and will explain why Domain Debt needs to be taken more seriously.</p><h3>What is technical debt?</h3><p>When I ask what technical debt is, answers may vary. Some say it is the postponement or even the non-execution of certain tasks. Who has not heard that documentation was not updated or code was not tested? Others may say it is simply poor programming style, missing coding standards, or usage of anti-patterns. However, a common point in all definitions seems to be that technical debt primarily acts as an expense driver. Software that contains technical debt is harder to write and maintain than software without technical debt. It simply takes longer and therefore is more cost intense. The longer technical debt persists, its elimination becomes more and more expensive, too. Additionally, writing further code on top of it, things become even worse.</p><p>In the software industry we seem to get used to this kind of debt. We try to fight it, but somehow, we cannot avoid it. No judgement!</p><p>However, as an industry we rarely or never discuss business-driven or as I call it Domain Debt. I have not even heard someone ever considering such a thing. Or did I?</p><h3>(Mis)Understanding</h3><p><a href="https://twitter.com/ziobrando">Alberto Brandolini</a> once said</p><blockquote><a href="https://twitter.com/dechampsgu/status/857924498280124416">„It’s developer’s (mis)understanding, not expert knowledge, that gets released in production.“</a></blockquote><p>If this is true (and I do believe it is), am I correct to claim that developers must become domain experts? I am convinced this should be the case. Even more, I sometimes meet such developers — sorry, domain experts — out there.</p><p>But what if developers are not such experts, yet? What if developers are in a learning process, becoming experts? They are making failures, because failure is vital to learning. For example, sometimes developers tend to assume that concepts and models from other contexts of the domain are applicable within ther current context of work. Sometimes they build inaccurate abstractions and models, because they are missing context information — simple things like the big picture or how their current task conforms to user’s needs or business process. As a result, rework and refactoring is inevitable. And more often, developers make (probably misled) hundred thousand dollar decisions by writing code that does not align with business goals which noone has ever clearly expressed.</p><p>Whatever kind of failures or misunderstandings, it will be reflected in code. We are spending time writing code and hopefully gaining further insights while doing so. We are refactoring code, adjusting models, re-shaping contexts, or changing teams and responsibilities. This takes time, effort, and money. So, is not this code an expense driver? Is this debt — domain, non-technical debt?</p><h3>A story on debt analysis</h3><p>Let me give you a concrete example to explain what I mean.</p><p>I was working with a few teams on a large project re-implementing parts of a software system for a railway company. Of course, when working on a railway system you are modelling (sometimes not so) obvious things, such as train runs, segments, route sections, legs, stops, and so on.</p><p>We had contexts and use cases which heavily relied on different models of train runs. In one context a train run consists of a sequence of stops. A stop basically refers to a train station and an arrival and departure time. In other contexts, we had use cases which made use of train runs consisting of a sequence of sections. A section has an origin and destination station with departure and arrival time, respectively. Moreover, there were models where a train run consists of a sequence of segments, each segment consisting of sections. Other in turn consists of segments which consist of stops.</p><p>Sometimes these models seem to be interchangeable, though they differed in subtleties. For example, you could easily transform a sequence of sections into a sequence of stops. However, depending on context, one or the other model did suit a certain use case better than another.</p><figure><img alt="4 variations of train run models" src="https://cdn-images-1.medium.com/max/860/0*geC4xtyeHMO9wR6e" /><figcaption>Variations of train run models</figcaption></figure><p>Back then we had a team which was struggling with implementation of certain use cases. Implementation felt awkward to them and every change to the software took quite a while. The team had discussions with an architect and came back with a „new“ model. They drew some UML diagrams and were quite happy with their achievements. When it came to cost and effort estimation for a refactoring (basically a rewrite of core parts), the estimated effort was quite high. Hence, we tried to figure out a way to have an incremental refactoring which allows them to gain some quick wins upfront.</p><h3>Reducing debt by gaining insight</h3><p>We tried to find such quick wins by analyzing the code and especially the change history of code. By using methods from Adam Thornhill’s book <a href="https://pragprog.com/book/atevol/software-design-x-rays"><em>Software Design X-Rays</em></a> — interestingly subtitled <em>Fix Technical Debt with Behavioral Code Analysis — </em>we could find some hotspots in code. These hotspots were parts of the code which seem to have a high complexity, underly a bunch of changes, had a high coupling, and were touched by nearly all developers at some point.</p><p>I did some more investigation on these hotspots and found some interesting insights. When I looked at the history of that code, I first found a method introduced which looked similar to this:</p><pre>List&lt;Section&gt; getSections() {<br>    return getSegments()<br>        .map(segment -&gt; segment.getSections().stream())<br>        .collect(Collectors.toList();<br>}</pre><p>This method was used to support delta calculation in case train runs change, e.g. when additional stops are planned:</p><pre>List&lt;Delta&gt; calculateDelta(TrainRun base, TrainRun new) {<br>    return calculateDelta(base.getSections(), new.getSections());<br>}</pre><p>And I found a line of code like this:</p><pre>List&lt;Section&gt; sectionsAdded = detectSectionsAdded()</pre><p>where detectSectionsAddeduses the calculateDelta method.</p><p>Going forward in the history of that code, I came to a point where this last line was changed to</p><pre>List&lt;Section&gt; stopsAdded = detectSectionsAdded()</pre><p>This little change in wording made me curious. Were we calculating based on stops or sections here?<br>I dug into this change and found a corresponding change with the same commit in the calculateDelta method. The method changed to this:</p><pre>List&lt;Delta&gt; calculateDelta(TrainRun base, TrainRun new) {<br>    return calculateDelta(calculateStopsFrom(base.getSections()), <br>        calculateStopsFrom(new.getSections()));<br>}</pre><pre>List&lt;Stop&gt; calculateStopsFrom(List&lt;Section&gt; sections) {<br>    // ...<br>}</pre><p>And then later in history another change caught my attention. A change which moved the line of code which made me curious to another class and rephrased it to:</p><pre>List&lt;Stop&gt; stopsAdded = detectStopsAdded(diff);`</pre><p>On first, this looked like a simple refactoring. The delta detection algorithm was changed from working based on sections to working based on stops. But now the code was cluttered with transformations from segments to sections to stops … back and forth.</p><h3>Don’t make the same mistake twice</h3><p>After seeing this, I understood why the team was struggling with the implementation and could not get up to speed. To me it became clear that we needed to understand whether the algorithm should use stops or sections as core of the model. I assumed the team was going through a learning process and gained some insights while implementing the stop-based algorithm. Our UX designer and the product owner both confirmed my assumption during a review. For both it was clear that from an end-user perspective, only a stop-based algorithm made sense.</p><p>Remember that the team wanted to rewrite the service? I took a second look at the proposed „new“ model, especially the UML diagrams. At the core of a class diagram I saw a „TrainRun“ with „Sections“. And moreover, a saw „Stops“ derived from „Sections“. The total opposite of what the team had learned and the experts proposed.</p><p>Obviously, I totally advised against this rewrite. Instead I proposed some smaller refactorings to get rid of the sections at all. However, that is not the point. My key takeaway from this was not my dissuasion, but a question that came to my mind.</p><h3>What am I trying to tackle here?</h3><p>What am I trying to tackle here? The team wanted a refactoring. I was suggesting a refactoring. Are we not doing refactorings, because of technical debt? At least that is what I hear throughout most of our industry. „We need to refactor this, to reduce technical debt.“</p><p>In contrast, the large codebase built around the existing section-based model was clean, well tested, and followed many software design principles. However, the model was fundamentally wrong due to the developers having a lack of expertise in this part of the domain. As a result of this design choice, the cost of adding every new feature was higher than it needed to be if the model had been stop-based.</p><p>What about debt? As said before, debt primarily acts as an expense driver. The initial implementation of the model took time and money. So did the refactorings done by the team. The rewrite would have even cost a lot of money. So, in this sense, there were a couple of expense drivers.</p><p>But was this technical debt? No word about microservice, Kafka, Kubernetes, databases, missing documentation, bad coding style, little code coverage … you name it. Just a model that did not suit the use case. Maybe just developer’s (mis)understandings in code. Beside that code may always be a technical artifact, I could not find any technical aspects here.</p><h3>Domain debt</h3><p>So this is not technical debt, it’s business understanding debt, or as I like to think of it domain debt. And there are tons of such debt out there. We as a software industry, we talk way to little about it. We take way to less responsibility for it.</p><p>I see a lot of responsibility within the Domain Driven Design (DDD) community, though. Carving domains with bounded contexts to keep models consistent and demarcate them. Or keep an Ubiquitous Language to build a rigorous and common language for everyone involved in the project. Look at methods like Event Storming or Domain Story Telling to get a quick basic understanding of the domain in even early product/project stages.</p><p>We have the tools and methods at hand to prevent such Domain Debt. Now developers, product owners, projects managers, and everyone involved in our industry, please take your responsibility to prevent and tackle Domain Debt.</p><h4>Acknowledgements</h4><p>This article was first published at <a href="https://conciso.de/">conciso.de</a>. An extended version is availabe in German at <a href="https://www.heise.de/developer/artikel/Fachliche-Schulden-als-Kontrapunkt-zu-Technical-Debt-4284588.html">heise Developer</a><em>.</em></p><p>Thank you <a href="https://medium.com/u/d012fdeb34b0">Nick Tune</a> for the review of the first draft, your feedback and contribution.</p><p>Thank you DDD Europe for hosting my talk.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FdFB158spi0U%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DdFB158spi0U&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FdFB158spi0U%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/dfdfa7d61debed7590a8809db0e966c7/href">https://medium.com/media/dfdfa7d61debed7590a8809db0e966c7/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5bcf838041f7" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>