<?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 Yannis Rizos on Medium]]></title>
        <description><![CDATA[Stories by Yannis Rizos on Medium]]></description>
        <link>https://medium.com/@yrizos?source=rss-11268a56bad5------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*4sq20XLVA9QmJBLPSJJtOQ.jpeg</url>
            <title>Stories by Yannis Rizos on Medium</title>
            <link>https://medium.com/@yrizos?source=rss-11268a56bad5------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 17:54:48 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@yrizos/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[Turn the Ship Around!]]></title>
            <link>https://medium.com/@yrizos/turn-the-ship-around-af66e0df88df?source=rss-11268a56bad5------2</link>
            <guid isPermaLink="false">https://medium.com/p/af66e0df88df</guid>
            <category><![CDATA[david-marquet]]></category>
            <category><![CDATA[engineering-leadership]]></category>
            <category><![CDATA[engineering-management]]></category>
            <category><![CDATA[book-review]]></category>
            <dc:creator><![CDATA[Yannis Rizos]]></dc:creator>
            <pubDate>Wed, 12 Aug 2026 14:25:51 GMT</pubDate>
            <atom:updated>2026-08-12T14:25:51.704Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="A single submarine floats alone in open, dark water." src="https://cdn-images-1.medium.com/max/1024/1*C2pyjuT75V22OLT4D2f_Hw.png" /></figure><p>The part of <em>The Hunt for Red October</em> that stayed with me was not the defection plot or the torpedo in the final act. It was the control room. A dozen people reading the ocean through sound alone, making calls in seconds that the surface world would have spent a month of meetings on. I did not follow the Cold War politics at all as a child. I followed the room.</p><p>That room turns up again in most of what I have loved since about crews who leave the atmosphere instead of the surface. Strip either setting back and the same frame sits underneath, a sealed hull with something outside it that kills on contact, a crew small enough that every person’s competence is load-bearing, and nobody reachable in time to make the decision for them.</p><p>Which is roughly the frame I brought to David Marquet’s <em>Turn the Ship Around</em>, and it is not the one the book gets shelved under. Marquet took command of a submarine he had not been trained on, with no time left to learn it, and for the first stretch that reads as a coordination problem rather than a leadership one. How does a crew make sound decisions before anyone aboard has had time to become the authority on the boat? The leadership argument arrives once those two questions turn out to be the same question.</p><h4>Santa Fe and the Leadership Shift</h4><p>Marquet had spent close to a year preparing to command a different submarine, learning its systems the way the Navy expects a new captain to. The reassignment to the USS Santa Fe came at the last minute, and it came without a second year attached. He would take over a crew and a set of systems he did not know, on a schedule indifferent to that.</p><p>Santa Fe was the worst-performing submarine in the Pacific fleet at the time. Re-enlistment was the lowest anywhere in it, morale was poor, and officers and crew advanced more slowly than their counterparts on better boats.</p><p>The stakes on that boat are not the stakes of a software organization, and nothing here treats them as though they were. A submarine crew’s mistakes can kill people within minutes. An engineering team’s worst week, genuinely bad as those get, does not run on that clock and does not carry that cost.</p><p>What carries over between the two is narrower and more useful than an analogy. It is the shape of the constraint, a leader with no runway to build expertise before the decisions start arriving anyway.</p><p>Marquet’s response to a boat he did not know was not to out-study it. It was to stop requiring that the expertise sit with him at all.</p><p>The Navy he had come up through ran on what he calls a leader-follower model. Authority concentrated at the top and instructions moved downward, which works well enough while the person at the top genuinely does know the most about the thing being decided. On Santa Fe that condition was simply false, and a crew trained to wait for orders from someone who could not yet give good ones is a crew that waits.</p><p>The leader-leader model he built instead moves authority to wherever the relevant competence and information already sit. Not handed out as a gesture toward autonomy, but relocated to where the knowledge to use it was already sitting.</p><h4>The Engineering Bottleneck</h4><p>The version of that constraint I keep meeting at work has nothing to do with hulls. It shows up as decision latency, the gap between a decision becoming necessary and someone with the authority for it actually being available. A team that has to locate an approver before it can act has built a queue into its own operations, and the queue doesn’t care whether the person at the head of it actually knows the most about what’s waiting.</p><p>Incidents make this obvious fastest. Authority to act during an outage belongs with whichever engineer is holding the pager, not with a central approver who has to be found and briefed while the system stays down.</p><p>Design review is the slower version of the same question. Whose opinion counts on an RFC is properly a function of who understands the part of the system under discussion, and a process that weights titles instead ends up with documents approved by people who could not have written them.</p><p>For anyone promoted because they were the strongest engineer in the room, the uncomfortable part is what Marquet calls the expertise trap. The instinct that earned the promotion, taking the hardest problem personally, becomes the ceiling the team cannot grow past. Engineers around that person stop developing judgment nobody ever asks them to use, and the organization ends up with one deep well of competence and a queue in front of it. A captain whose crew will not submerge without checking first has built the same bottleneck by a different route.</p><h4>Control, Competence, Clarity</h4><p>Relocating authority only works when three conditions hold at once, and most of the book is a study in what breaks when only two of them do. Marquet names them control, competence, and clarity.</p><p>Control is the decision right itself, sitting with whoever is closest to the work rather than three levels above it. It is also the cheapest of the three to hand over and the most dangerous to hand over alone, since a decision right given to someone not yet equipped to use it is not empowerment.</p><p>Competence is what makes that handover safe rather than reckless, and Santa Fe’s version of it was unglamorous. Sailors qualified for each system they were trusted to make calls about, in front of peers who had already qualified and could ask anything they liked, and a wrong answer meant going back to study rather than being waved through out of politeness. Nobody held authority over a system they could not explain on demand. That is the part of the leader-leader story that gets dropped when the phrase travels on its own.</p><p>Clarity is the shared purpose and standard that keeps a hundred separate good decisions pointing the same way. Without it, control and competence produce a capable crew whose sensible individual calls do not add up to a coherent boat.</p><p>The first mechanism is a change in what officers were permitted to say out loud. Rather than requesting permission to submerge, they stated the intention, and a superior either stopped the sentence or let it stand. An incident commander announcing a rollback instead of paging upward and waiting to be told is running the identical script.</p><p>Deliberate action takes the same instinct further. Before doing anything non-trivial the crew said aloud what they were about to do and paused first, which is the pause separating a reread diff from a trusted commit message.</p><p>Certify, don’t brief inverts who has to demonstrate understanding. Instead of one person walking a plan past a room that nods, the people closest to the decision had to show they understood it themselves, and anyone present could be asked about any part of it on the spot. A design doc that collects a thumbs-up emoji in a channel has been briefed. One whose author gets asked to walk through its failure modes, live, and does, has been certified. The artifact is identical. The difference is whether anyone was tested against it.</p><p>Embrace the inspectors is the one aimed outward. External inspections were treated as free information about the boat rather than an event to survive, which is the posture a mature team already takes toward a security audit.</p><h4>Judging the Book</h4><p>As a book, its strongest quality is honesty, which is rarer in this genre than it should be. Management memoirs tend to arrive pre-polished, the author’s early mistakes edited into foreshadowing. Marquet leaves the false starts in, including orders he gave that turned out to be impossible to carry out, and he mostly resists the vague appeals to vision that pad out the shelf around him.</p><p>The mechanisms are also concrete enough to be tried rather than admired. A team could run the intention-stating change on Monday and know by Friday whether anything moved, which very few leadership books can offer.</p><p>The sharpest thing in it, though, is that Marquet names the expertise trap himself rather than leaving a reader to work it out. He is explicit that the instinct to be the most capable person in the room is the thing a leader has to give up, and that giving it up feels like a loss while it is happening rather than a promotion. Most books in this category gesture at that much. Naming it plainly is what makes this one generalize past submarines at all, more than any of the four mechanisms manage.</p><p>Where it is weaker is in what it takes for granted. The Navy pre-qualifies people against hard technical standards long before they reach a boat, so a large part of Santa Fe’s competence condition was built elsewhere and simply handed to him. Most engineering organizations have no equivalent pipeline and cannot conjure one.</p><p>Marquet’s own autonomy was unusual too, and so was his timing. A captain handed the fleet’s worst boat has room to experiment that a captain of a merely mediocre one does not.</p><p>The later chapters lose their edge as well. The same three-condition logic gets re-applied to fresh scenes without gaining much from the repetition, and the chapter-end summaries with their reflection questions read less like a memoir than like a training module bolted onto the back of one. I found the first half considerably stronger than the second.</p><p>None of which touches the record. Santa Fe went from worst-performing submarine in the Pacific fleet to best-performing in about a year, and the command became an unusual source of officers who went on to lead well elsewhere.</p><p>The fact I find hardest to argue with is what happened after Marquet left. The performance held, which is the detail separating a structural change to a boat from one captain’s force of personality.</p><p>Marquet is explicit that this does not license copying his mechanisms. The exact wording of an intention statement and the specific shape of a qualification board are local artifacts, and the durable layer beneath them is control, competence, and clarity. Which of those three a given organization is actually missing, and what would have to be built to supply it, is a question the book cannot answer from outside and does not pretend to.</p><h4>What Transfers for Engineering Leaders</h4><p>What an engineering leader can take from this is narrower than three memorable words and narrower than the book’s own enthusiasm. It is a reason to treat decision latency as a design problem rather than a personality one, and a question worth asking of every recurring decision, whether the person making it is the best positioned to make it or merely the one with signing authority. Most organizations have more of the second kind than they would guess.</p><p>For a technical leader promoted for exactly the instincts this asks them to set aside, the practical version is smaller than a restructure. It is noticing when a decision has been routed upward out of habit rather than need, and sending it back down to whoever was closest to it.</p><p>I had already <a href="https://blog.talentlms.io/posts/the-job-before-the-job/">designed and run an internal initiative</a> for engineers moving into their first tech lead roles, and I had not read <em>Turn the Ship Around</em> when it was being designed. The overlap between what that work kept circling and what Marquet’s three conditions describe was something I noticed afterwards, not a framework I had been building from. Which says more about how reliably that gap appears than about either.</p><p>Whether the transfer is ever complete is not something the book settles, and I doubt that it is. What it does supply is a name for the bottleneck, early enough to be recognized before a team has learned to wait.</p><p>I’m long overdue a visit to <a href="https://averof.hellenicnavy.gr/en/from-proteus-to-nereus-from-mythology-to-the-silent-power-of-the-fleet/">Proteus</a>, a submarine-turned-museum. It’s not the real thing, but still awesome.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=af66e0df88df" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Job Before the Job]]></title>
            <link>https://medium.com/@yrizos/the-job-before-the-job-6353ecfb0fc4?source=rss-11268a56bad5------2</link>
            <guid isPermaLink="false">https://medium.com/p/6353ecfb0fc4</guid>
            <category><![CDATA[engineering-leadership]]></category>
            <category><![CDATA[engineering-mangement]]></category>
            <category><![CDATA[professional-development]]></category>
            <dc:creator><![CDATA[Yannis Rizos]]></dc:creator>
            <pubDate>Mon, 22 Jun 2026 00:00:38 GMT</pubDate>
            <atom:updated>2026-08-02T01:32:00.065Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="Painterly planning wall covered with layered papers, loose diagrams, connecting lines, and sticky notes." src="https://cdn-images-1.medium.com/max/1024/1*17SvpRpR3u8hW0VJc_4D2A.png" /></figure><p>Back in January, I sat across from a tech lead on a video call and asked what had surprised them most about the role. The answer came back without hesitation: “Nobody tells you that writing code stops being the job.” Then they added the part that lingered: “And nobody tells you that you’ll miss it.”</p><p>I ran five of these interviews with our tech leads, each built around the same handful of questions. What do you wish you had known? What took the longest to learn? Where did you feel least prepared?</p><p>The answers overlapped far more than I expected. Every one of them named some version of the same gap. The skills that earned the promotion were not the skills the job turned out to need. They had been promoted for being excellent engineers, and the role was quietly asking them to become something else.</p><p>That gap is not ours alone. It is the defining structural problem of technical leadership across the industry. You reward someone for individual excellence, hand them a team, and hope the rest follows. Sometimes it does, and often it does not.</p><p>That is the problem Tech Lead School was built to address. Not to manufacture a tech lead in four weeks, which would be absurd. The aim was smaller and more honest: to give engineers a place to practice the work before the work depended on them getting it right.</p><h4>The Shift</h4><p>If I had to name the one concept that landed hardest, it would be the shift in identity from maker to multiplier. Pat Kua’s <a href="https://www.patkua.com/blog/maker-vs-multiplier/">framing of that transition</a> was the takeaway nearly every participant reached for first.</p><p>The recognition came quickly, and it was uncomfortable. The job is to make the people around you more effective, rather than to be the most effective individual in the room. That reads cleanly on the page. It is far less clean when you have spent years being rewarded for solving the hardest problems yourself.</p><p>One participant put it plainly:</p><blockquote><em>I still measure my productivity by code output. If I am not shipping code, I feel unproductive, but the job asks me to make others more productive.</em></blockquote><p>That sentence is the whole transition. A tech lead does not stop being technical. They stop using their own output as the main proof that they are doing the job.</p><p>The same recognition shows up a level higher. In <a href="https://blog.talentlms.io/posts/the-subtraction-job/">The Subtraction Job</a>, Konstantinos Chatzinikolakis opens with the manager’s version of it:</p><blockquote><em>For most of my first decade as a manager, I measured myself by what I added.</em></blockquote><p>A tech lead feels it as code shipped, a manager as comments and rewrites added, yet it is the same trap underneath. The work changes before the identity has time to catch up.</p><p>I am not writing this as someone who has it all figured out. I delivered five of the presentations myself, across four sessions. I wanted to, and handing them off would have meant watching someone else run them. The whole program was about stepping back, and I would not step back from it. It is hard to demonstrate the trap more clearly than that.</p><p>That tension does not resolve in a single session. It resolves over months, as you keep choosing to unblock someone else instead of writing the code yourself. The harder part is coming to believe that the unblocking was the real work all along.</p><h4>The Shape of the Job</h4><p>Before building anything, I needed a map.</p><p>The five interviews produced one, and it lined up closely with the formal role definition we already had. Together they named six areas of responsibility that a tech lead has to operate across at the same time.</p><figure><img alt="Six equal hexagonal panels form a ring around an empty center, showing the six core responsibility areas of a Tech Lead: Technical Leadership, Team Support, Delivery Ownership, Strategic Involvement, Reliability, and Cross-functional Coordination." src="https://cdn-images-1.medium.com/max/900/0*TH6GDYjAcgHzaM5s.png" /></figure><p>The breadth is the whole point. A senior engineer can afford to go deep in one or two of these areas. A tech lead does not get that luxury. Technical Leadership, Team Support, Delivery Ownership, Strategic Involvement, Reliability, and Cross-functional Coordination all land in the same week, and that breadth is exactly what nobody practices before stepping into the role.</p><p>Most engineers are promoted because they have proven they can handle difficult technical work. Then the role asks them to hold a far wider field in view. The architecture still matters and the code still matters, but so do the estimates, the reviews, the tradeoffs, the team dynamics, the customer impact, the operational risk, and the conversations happening well outside engineering.</p><h4>The School</h4><p>The program ran in March 2026: eight sessions across four weeks, twenty-three hours in total, with ten participants drawn from teams across engineering. Seventeen people contributed, four of them from outside engineering, in Product, Compliance, Customer Support, and Marketing.</p><p>Several of the participants had come up through <em>Dev Academy</em>, an internal program on SDLC basics that we ran back in 2021 for interns and junior engineers. None of us planned it as a route into technical leadership. It became one anyway.</p><p>The design followed from the role itself. Every hour had to map to one of the six responsibility areas. Nothing earned a place in the curriculum because it seemed interesting. Everything was there because the role demanded it.</p><p>It also had to be practical. Participants made decisions, produced artifacts, and defended their tradeoffs. The exercises carried ambiguity, time pressure, competing priorities, and incomplete information, because clean problems with clean solutions prepare nobody for the actual job.</p><p>The practice stayed concrete. Participants ran a Domain Storytelling workshop and worked through an Elephant Carpaccio slicing exercise as live sessions. In smaller exercises they classified real debt with Fowler’s Technical Debt Quadrant and pulled apart an actual PRD. Take-home work asked them to diagram a greenfield system using the C4 Model, write ADRs, and practice Opportunity Solution Trees and RICE scoring.</p><p>The contributors came to show how they actually do the work, not to read from slides. An architect walked through how they approach a C4 diagram. A product manager explained how they really write PRDs and what they need from engineering in return. A senior tech lead described what changes once you stop measuring yourself by code output.</p><p>The contributors from outside engineering covered the parts of the role engineers rarely see up close. Compliance walked through what a tech lead has to sign off on, and why it matters. Support showed the thankless work that happens long before a ticket ever reaches an engineer. Marketing explained how we reach the real people who use the software, a question most engineers never have to ask.</p><h4>The First Signals</h4><p>The clearest signals were not the comments people offered at the end of the program. They were the things that shifted inside their teams almost immediately after. These are early signals rather than proof, and the real test is still ahead, but they are the kind worth trusting.</p><p><strong>Estimation changed daily behavior.</strong> The most reported change had less to do with technique than with understanding what an estimate is actually for. One participant put it this way:</p><blockquote><em>Estimation is not about getting the number right, it is about surfacing what you do not know.</em></blockquote><p>That distinction stuck. A commitment is a promise, while a prediction is only a forecast, and most teams quietly treat the second as if it were the first, then wonder why trust erodes.</p><p><strong>Code review changed first.</strong> One participant described the shift:</p><blockquote><em>I stopped writing vague comments like ‘this could be cleaner’ and started naming the actual risk, like ‘if this dual-update is missed, state becomes silently inconsistent.’</em></blockquote><p>The comments moved from opinion to observation, from preference to consequence. And they showed up in pull requests within days rather than weeks.</p><p>That is the kind of change I care about most. Not whether someone can recite the name of a framework, but whether the next estimate, review, or team discussion comes out a little more precise because of it.</p><h4>The Failure</h4><p>I am more interested in what failed than in what succeeded, because the failures are where the design problems actually live.</p><p>The program contradicted one of its own beliefs. We knew leadership development needs practice inside real work, and then we ran two sessions a week for four weeks. New concepts kept landing before anyone had applied the last ones, which was the most consistent complaint we heard and the most warranted.</p><p>The activities themselves were fine. What we squeezed out was the room around them, the space to test the ideas against real work and let them settle.</p><p>The evidence was not subtle. Participants described drifting during back-to-back sessions and asked for more time on exercises that got cut short. One put it as wanting “30% concepts, 70% simulations and real scenarios,” and we had that ratio backwards. The pressure reached the people running the sessions too, and in the worst case I finished my own slides a minute before one began.</p><p>If I could change one decision, I would spread the same material across eight weeks instead of four. The research is clear that training without on-the-job application produces very little lasting change. We knew that going in, and the timeline talked us out of it.</p><p>Cohort 2 will not repeat the mistake. We have taken everything the program produced and started building a Tech Lead Foundations learning path inside our internal installation of TalentLMS, so the next group has plenty to work through before any live session begins. That frees the synchronous hours for what Cohort 1 kept asking for: discussion and hands-on practice instead of presentation.</p><h4>The Honest Version</h4><p>Twenty-three hours will never make someone a tech lead, and I never expected them to. What the program can produce is engineers who have practiced the work before the pressure arrives, who have language for the problems ahead, and who have seen the full breadth of the role before anyone asks them to operate across it.</p><p>That time, multiplied across ten participants and seventeen contributors, is a fair thing to question. None of it paused the work. For participants and contributors alike, the program ran alongside business as usual.</p><p>The honest comparison is not against the hours we spent. It is against the lead who never got to practice, the one who quietly becomes the bottleneck nobody named, whose team learns to wait, who keeps paying a cost that never arrives as an invoice.</p><p>The gap between what earns the promotion and what the job demands does not close in four weeks. It does close faster when people have already made the decisions, met the frameworks, and felt the discomfort of the shift before a team depends on them getting it right.</p><h4>The Work Before the Work</h4><p>Five years separate the interns in that first Dev Academy session from the engineers now preparing to lead teams. None of it paid back on the schedule I expected, and that is the part I keep relearning. The investment compounds quietly, in people, long after you have stopped watching for it.</p><p>Building this was hard and slow, and worth every hour. Not because it produced a program, or a next version of something we had already built, but because it created the conditions for people to grow into responsibilities they could not yet name.</p><p>The job will change. Parts of it will be harder than they expect, and parts of it will be difficult precisely because they will miss what they are leaving behind.</p><p>This time, at least, someone told them early enough to practice.</p><p>P.S. For a taste of Tech Lead School, I made our <a href="https://github.com/yrizos/leadership-micro-katas">Leadership Micro Katas</a> public. Small deliberate-practice exercises for engineers not yet in the role. Contributions welcome.</p><p><em>Originally published at </em><a href="https://blog.talentlms.io/posts/the-job-before-the-job/"><em>https://blog.talentlms.io</em></a><em> on June 22, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6353ecfb0fc4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[One Bloody Character]]></title>
            <link>https://medium.com/@yrizos/one-bloody-character-9d3d3ad45861?source=rss-11268a56bad5------2</link>
            <guid isPermaLink="false">https://medium.com/p/9d3d3ad45861</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[personal-growth]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[future-of-work]]></category>
            <dc:creator><![CDATA[Yannis Rizos]]></dc:creator>
            <pubDate>Wed, 15 Apr 2026 12:53:04 GMT</pubDate>
            <atom:updated>2026-04-15T12:53:04.062Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="Abstract painted figure, arms raised in fury, facing empty space. The target is gone. The energy has nowhere to go." src="https://cdn-images-1.medium.com/max/1024/1*pkMw_uU_w-0qjKUPxOC0aw.png" /></figure><p>The fix was a single character, and I was furious for the rest of the evening.</p><p>Cursor had written a perfect expectiminimax evaluator, all tests green. Or so I thought. The scores seemed slightly off on certain paths. Not obviously wrong. It made sensible decisions on most inputs. On the ones where it did not, the wrongness was faint enough that I was almost convinced I was misreading my own algorithm.</p><p>Forty minutes of uninterrupted time is what a Tuesday evening gives me after putting my baby girl to bed. I had already burned most of it staring at traces that looked <em>fine</em> when I pressed the tool to investigate. It found the sign flip in minutes, explained the inversion, and applied the fix.</p><p><em>One bloody character</em>.</p><p>I went back and looked at the test. It had been encoding the buggy sign from the start. The code and the test had been wrong in exactly the same way, and the green build had been proof of nothing. Mechanical compliance.</p><p>Objectively, I lost less than an hour. The tool handed most of it back. The evaluator worked. By any reasonable measure, this was a trivial issue with a speedy recovery. I was livid, and I knew the anger made no sense at all.</p><p>But I was livid anyway.</p><h4><strong>The Window</strong></h4><p>The time for building had been shrinking for years. Architectural work, cross-functional coordination, the organizational lifting that never shows up on any dashboard but quietly consumes most of a working week: none of it was going away. What remained were fragments. The hour after bedtime. A Saturday morning before the house wakes up. Not days. Hours.</p><p>Augmented coding changed whether those fragments were worth starting. I <a href="https://medium.com/@yrizos/the-end-of-coding-as-we-know-it-f5446f6c7806">wrote a while back</a> that this looked like progress, and I stand by it. The tool gave me something I had almost stopped expecting: a second life in the code.</p><p>I could pick up an unfamiliar technology in the evening and have something running before midnight. Barriers that once required a couple of days simply disappeared. I remember the first time a fragment actually produced something real, not a half-started sketch I would need to re-enter the following week, but a working service in a language I had barely touched.</p><p>The feeling was not productivity. It was closer to relief. The part of me that builds things, the part that had been going quiet under the weight of everything else a senior role demands, was still there. Augmented coding did not just make the hour more efficient. It made the hour possible.</p><p>When a single-character bug eats the hour and the tool finds and applies the fix in minutes, the question is not just why I am furious at midnight. It is what exactly was lost that makes a trivial bug, in a recovered hour, in a personal project that nobody depends on, feel like something worth being furious about at all.</p><h4><strong>What the Old Failures Left Behind</strong></h4><p>I have been doing this for over twenty years. I have had my share of production incidents. Systems down for hours. Features rolled back on a Friday evening. Bugs that took days to trace, not because they were clever but because understanding them required understanding the system, and there was no shortcut to it.</p><p>Those were objectively worse than a sign flip in a personal project on a Tuesday night. They cost more, took longer, and hurt more people.</p><p>They did not make me this angry.</p><p>When those incidents were over, there was something on the other side. A part of the codebase that was now known in a way it had not been before. The hour spent staring at a wrong function signature was also an hour spent learning why the abstraction had been shaped that way. The debugging revealed the design.</p><p>The frustration was not separate from the learning. It was the mechanism through which the learning happened. I am not going to romanticize this. Those sessions were brutal, and anyone who has inherited a system that took days to understand just to fix a single defect knows there was nothing pleasant about the process.</p><p>But the knowledge that came out of it was durable. It lived in the hands. You could feel it when you touched that part of the code again months later, the quiet confidence of having been inside the problem and coming out the other side knowing how it held together.</p><p>The mess was the learning. That is what the old failures left behind. The new ones do not.</p><h4><strong>What Gets Compressed</strong></h4><p>Augmented coding compresses the process. What gets compressed is not the debugging but the slow hours where the code becomes familiar through building.</p><p>Wax on, wax off.</p><p>In a <a href="https://www.youtube.com/watch?v=vagyIcmIGOQ">conversation with Lex Fridman</a>, DHH described competence draining from his fingers. He found himself asking the AI for the same syntax patterns over and over, never learning them because he never typed them.</p><p>Alexandru Nedelcu catalogues the same loss in <a href="https://alexn.org/blog/2025/10/27/ai-sucks-the-joy-out-of-programming/">AI Sucks the Joy Out of Programming</a>: an LLM-driven workflow that delivers all the bad parts, the stress of not being in control, the desperate trial-and-error, and none of the gratification that comes from the journey itself.</p><p>The slow, frustrating work of the good old days was not waste to be eliminated. That was where psychological ownership of the work was built. Not just knowing what the code does, but the felt sense of having shaped it from the inside, of being the person who wrestled it into its current form.</p><p>The fun of building was in the building itself. When that process is compressed, the understanding that would have come from it does not arrive through some other channel. It simply does not arrive.</p><p>And the anger I felt staring at a one-character fix at eleven on a Tuesday night was not really about the bug. It was about the absence of everything that used to follow.</p><h4><strong>The Drift</strong></h4><p>There is another texture to the loss, and it comes with its own particular absurdity.</p><p>Ask the tool to fix something specific and it may not adjust the specific thing. It may reimagine the surrounding structure entirely, like asking someone to move a chair and coming back to find they have redecorated the room. The result looks plausible, passes a quick scan, and is absolutely not what was intended.</p><p>Ask again and it overcorrects in a different direction. You are now chasing the output rather than steering it, trying to recover a shape that existed three iterations ago and is gone.</p><p>There is also a discipline to this nobody warned you about: you have to be calm. The moment your feedback carries any trace of frustration, the model interprets it as a signal that <em>everything</em> is wrong. Measured, specific, almost zen-like correction is what works. Anything that reads like impatience triggers a panicked reimagining that leaves you further from where you started.</p><p>The tool is at its most destructive precisely when you are at your least patient, which, if you have forty minutes and the code just drifted sideways for the third time, is most of the time.</p><p>Simon Willison has a <a href="https://simonwillison.net/2025/Mar/19/vibe-coding/">rule</a> for this:</p><blockquote>do not commit code you cannot explain to someone else</blockquote><p>The rule sounds simple. It is considerably harder to follow when the window is almost closed and the tool has just produced something that appears to work.</p><p>A couple of weeks after the green test incident, an agent ran a destructive git restore mid-session. The safety protocols I had configured did precisely nothing. Gone. Everything I had built that session, gone. And the tool rebuilt it in minutes. That was somehow the worst part. The loss that had felt catastrophic was already undone, the fury left hanging with nowhere to land, because you cannot stay enraged at something that fixed itself before you finished swearing at it.</p><p>Neither incident lasted more than a few hours. Neither left behind the durable knowledge that the old failures used to produce. They were small enough that there was nothing to learn from them, and the fury that followed was not proportionally small. That is the paradox. Augmented coding makes failures smaller, faster, and cheaper to recover from. The smaller failures feel worse than the expensive ones used to.</p><h4><strong>Responsibility Without Authorship</strong></h4><p>The knowing disappears. The responsibility does not go with it. I shipped the evaluator.</p><p>I am accountable for it. That accountability has nothing to do with how much of the code I personally understood at the moment I committed it. Nobody downstream will ask whether the green test was machine-generated or hand-written. The failure belongs to the person who shipped it.</p><p>Addy Osmani calls this the knowledge paradox in <a href="https://addyo.substack.com/p/the-70-problem-hard-truths-about">The 70% Problem</a>. AI tools help experienced developers more than beginners, because experienced developers can evaluate and constrain the output. But that same experienced developer is now evaluating output they did not build, and the understanding that would have come from building it was compressed out along with the process. The gap between what was shipped and what was understood widens with every cycle. The accountability does not narrow to match.</p><p>You begin to feel like a reviewer of your own work. Not the builder who shaped the code, but the bureaucrat who approved it.</p><p>It is impostor syndrome, except the impostor is real. You genuinely did not write most of this. You are genuinely uncertain whether you could have. The tool is lightning fast and you… a bottleneck?</p><p>The thought that follows, the one you push away because it is irrational and premature, is that the tool that introduced the bug might eventually make you unnecessary. The fear does not survive examination. It survives anyway. And it colours everything else: the sign flip is not just a sign flip when part of you wonders whether you are watching your own obsolescence in slow motion.</p><h4><strong>Both Live in the Same Hour</strong></h4><p>It is late on a Tuesday, the house quiet and the editor open. The hour is running out, the way it always does.</p><p>The gains that made this hour worth starting are not rhetorical. Augmented coding gave me back something that was genuinely slipping away. I can pick up where I left off without the long re-entry cost that used to consume half the window. I can reach technologies that would have taken weeks to approach. The second life in the code is real, and I am not willing to give it up.</p><p>What I cannot hold at the same time is how the hour feels when something goes wrong. Not worse in any absolute sense. Worse in the specific sense that matters: the mess is no longer the learning. The small failures leave no knowledge behind, no ownership, no quiet confidence for next time.</p><p>A sign flip and a rogue git restore. Those are the only two incidents that came to mind across months of augmented building. Two small disruptions, both recovered in minutes. By any honest measure, the tool is doing its job. I am still furious.</p><p>I have <a href="https://medium.com/@yrizos/the-fastest-engineer-in-the-room-44168a7570b8">written before</a> about the cost that speed imposes on the organization around the maker. This is the cost it imposes on the maker. What building means when the tool works and the anger persists and neither fact explains the other, I do not yet know.</p><p>The window is closing. I start anyway.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9d3d3ad45861" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Fastest Engineer in the Room]]></title>
            <link>https://medium.com/@yrizos/the-fastest-engineer-in-the-room-44168a7570b8?source=rss-11268a56bad5------2</link>
            <guid isPermaLink="false">https://medium.com/p/44168a7570b8</guid>
            <category><![CDATA[engineering-leadership]]></category>
            <category><![CDATA[software-design]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[technical-debt]]></category>
            <dc:creator><![CDATA[Yannis Rizos]]></dc:creator>
            <pubDate>Fri, 13 Mar 2026 16:44:20 GMT</pubDate>
            <atom:updated>2026-03-14T23:57:11.125Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="A large tornado tears through the centre of the scene, scattering debris in every direction. In the foreground, a group of people stand facing the tornado with their arms raised in celebration. One of them holds a trophy above their head. They are cheering the destruction on." src="https://cdn-images-1.medium.com/max/1024/1*R2B47vbPb2o3i_sHr2sBeA.png" /></figure><p>A colleague mentioned the <strong>tactical tornado</strong> the other day. The phrase landed in a way it hadn’t in years, and I found myself back in two places at once: the pages of John Ousterhout’s <a href="https://www.amazon.com/Philosophy-Software-Design-2nd/dp/173210221X"><em>A Philosophy of Software Design</em></a>, and a meeting room where someone was asking me, as diplomatically as they could, to please slow down.</p><p>I have… opinions about the book. Some of its prescriptions feel too neat for the messy reality of production systems. But the tactical tornado was a direct hit. Ousterhout named something I had seen repeatedly but never had a clean language for.</p><p>And more uncomfortably, he named something I had been.</p><h4>Visible Output Wins</h4><p>Ousterhout’s central thesis is that complexity is the root problem of software and that it accumulates incrementally. Nobody decides to build a complex system. It emerges from hundreds of small decisions, each seemingly harmless, each adding a thin layer of friction that the next developer will have to work through.</p><p>The tactical tornado is the human embodiment of this accumulation: someone who makes those small decisions faster than anyone else, and always in the direction of more complexity.</p><p>Ousterhout draws a distinction between tactical and strategic programming. Tactical optimizes for the next feature, the next fix, the next thing that needs to ship. Strategic treats working code as necessary but insufficient; the real goal is a great design that also happens to work. The tornado is the extreme case of the tactical mindset: zero investment in design, maximum visible output, and a trail of shallow abstractions left behind for others to navigate.</p><p>Tactical tornadoes often get praised and promoted because their output is visible and their damage is not. The engineers who clean up after them appear to be making slower progress by comparison. This is how the incentive structure ends up working against the people doing the harder, more valuable work.</p><p>It does so reliably enough that you can predict the outcome: the tornado rises, the maintainers burn out, and the codebase degrades.</p><h4>Built for the System</h4><p>As I have already mentioned, I’m not writing this from the outside.</p><p>I have been the person called into a meeting and asked to slow down. The conversations were polite. The message was clear. I was producing code faster than anyone around me, and the wake I left behind was becoming a problem for the team.</p><p>At the time, I understood the feedback intellectually while feeling, somewhere deeper, that the real issue was everyone else’s inability to keep up.</p><p>That feeling is what makes the tactical tornado so difficult to correct. The speed is real. The output is real. The praise is real. The damage is real, too, but it is distributed across other people’s schedules, other people’s frustration, and future sprints that haven’t happened yet. The feedback loop that would correct the behaviour is delayed long enough that the behaviour gets reinforced instead.</p><p>I am not alone in this recognition. In an <a href="https://se-radio.net/2022/07/episode-520-john-ousterhout-on-a-philosophy-of-software-design/">SE Radio interview</a>, Jeff Doolittle told Ousterhout that there is a whole unnamed category of <em>recovering tactical tornadoes</em>, people who were never acting out of malice but responding to the incentives around them.</p><p>That framing matters.</p><p>The tornado is not a villain. They are often the person most adapted to survive in the system they are in.</p><p>If you treat the tornado as a character flaw, the solution is coaching or removal. If you treat it as a system outcome, the solution is to redesign the incentives. Both may be necessary, but only the second one prevents the next tornado from forming.</p><h4>Deeper Than Code</h4><p>Most commentary on the tactical tornado stays at the level of code quality. The tornado writes messy code, others clean it up, and complexity grows. That framing is accurate but incomplete, because it misses the organizational dimension entirely.</p><p>Conway’s Law runs in both directions. The organization shapes the system, and then the system shapes the organization back. The tactical tornado exploits this bidirectional dynamic in a way that is rarely discussed.</p><p>When a tornado moves through a codebase, other engineers route around the damage rather than engaging with it. They build interfaces that insulate their own work from the tornado’s output. Over time, this avoidance becomes structural. The team’s actual communication topology starts to reflect not the ideal architecture but the boundaries of the tornado’s impact area.</p><p>The tornado’s code is shaping the organization.</p><p>Even after the tornado moves on, or slows down, or gets promoted out of the code, the team carries the scar tissue. People still avoid those modules. Knowledge remains siloed in whoever was brave enough to touch it. New engineers inherit not just the messy code but the organizational habits that formed around it: the workarounds, the <em>unwritten rules</em> about which parts of the system you simply do not touch.</p><p>That is what makes the tornado problem an architectural problem, not just a code quality problem. The damage is sociotechnical. Refactoring the code is necessary but insufficient. You also have to refactor the team’s relationship to the code, which is a much harder and longer process.</p><p>Code can be rewritten in a quarter. Organizational scar tissue takes years to heal.</p><p>The effect is, of course, amplified when the tornado is also a senior engineer or a team lead. Their design decisions carry organizational weight. Their module boundaries become team boundaries. Their shortcuts become conventions. The system calcifies around their tactical choices, and what started as one person’s speed becomes the entire organization’s constraint.</p><p>The tactical tornado is not just a complexity accelerator. They are an organizational architect, designing the team’s communication structure without realizing it, and without anyone reviewing the design.</p><h4>Mess, Accelerated</h4><p>All this was already true long before augmented coding entered the room. What AI adds to the mess is scale.</p><p>Ousterhout himself, in a recent <a href="https://newsletter.pragmaticengineer.com/p/the-philosophy-of-software-design">conversation with Gergely Orosz</a>, described current AI coding tools as tactical tornadoes. They produce code fast, fix issues fast, and generate technical debt at speed. That characterization is sharp, but the deeper problem is not that AI acts like a tornado. It is that AI pulls the human toward tornado behaviour.</p><p><a href="https://olano.dev/blog/tactical-tornado">Facundo Olano</a> makes this argument clearly. LLMs operate task by task, diff by diff. There is no big-picture thinking in the process, no consideration of conceptual integrity. The human is supposed to supply those things, but the tool actively works against that mindset. The more detached you become from the low-level code, the harder it is to maintain a tight mental model of the system’s design and runtime behaviour.</p><p>I recognize this tension from my own work. The feeling of speed that AI provides is the same one I had in my code-writing days, the one that got me called into meetings. The difference is that now the speed is available to everyone, and the organizational structures that might have caught the damage are under pressure to get out of the way because they slow things down.</p><p>Code review, design discussions, and architectural governance. All of them feel like friction when AI can produce a working implementation in minutes.</p><p>There is also a troubling productivity question. Who gets a greater boost from AI coding tools: the strategic developer who invests in documentation, context, and design, or the tactical tornado who fires prompts and ships? <a href="https://positive-antagonist.com/tactical-tornadoes-in-the-age-of-ai-assisted-coding/">One analysis</a> suggests the tornado gets a higher multiplier because AI is already good at reaching a working state with minimum effort. If that is true, the share of tactically produced code will rise, and technical debt will accelerate across the industry.</p><p>The Conway’s Law dimension makes this exponentially worse. If AI-generated code shapes organizational communication patterns the way human-written code does, and there is no reason to think it would not, then the sociotechnical damage compounds faster than any team can address.</p><p>We are not just scaling the tornado’s code output. We are scaling the organizational distortion that follows it.</p><h4>Speed Is a Choice</h4><p>Having been the tornado myself, I can deliver this counterargument without hedging.</p><p>Speed is not inherently destructive. There are moments when tactical programming is the correct choice. A proof of concept that needs to validate a hypothesis before anyone invests further. A time-bound market opportunity where being second means being irrelevant. An incident response where the priority is stopping the bleeding, not writing elegant code.</p><p>Even Facebook’s engineering motto evolved over the years, from celebrating breakage to demanding stable infrastructure, which suggests the industry’s relationship with tactical speed is still being negotiated, not settled.</p><p>The problem is not speed itself but the failure to recognize when speed has become the default mode rather than a deliberate choice. The tornado does not choose to be tactical. They simply never switch out of it. And the organization, by rewarding their output, never gives them a reason to.</p><p>Ousterhout suggests investing 10 to 20 percent of development time in design improvement. That number is less important than the principle behind it: strategic thinking is not a separate activity from coding. It is a continuous investment, a small tax on every task that pays compound returns over time.</p><p>The tornado invests zero. They are not failing to invest. They are <em>actively divesting</em>, extracting design capital from the codebase, and converting it into visible output.</p><p>The question every team should ask is not whether they have a tactical tornado. It is whether their incentive structure would produce one.</p><h4>Listen to the Room</h4><p>Being asked to slow down did not feel like a gift at the time. It felt like a misunderstanding. I was producing more than anyone around me. The metrics confirmed it. The feedback from stakeholders confirmed it. The only people who seemed unhappy were the engineers working alongside me, and I could not yet see that their unhappiness was the most important signal in the room.</p><p>Understanding came later, gradually, through years of working on systems shaped by the same behaviour I had exhibited. Through inheriting code that was fast to write and brutal to maintain. Through watching teams route around modules that nobody dared touch. Through seeing, from the other side, how the tornado’s speed becomes the organization’s constraint.</p><p>Ousterhout gave me the language. The colleagues who pulled me aside gave me the correction. Both were necessary. Neither was sufficient on its own. The language lets you see the pattern. The correction lets you feel its cost.</p><p>If someone has pulled you into a meeting to ask you to slow down, do not treat it as criticism. Treat it as information about your impact, the kind that no metric will ever capture and no AI tool will ever flag.</p><p>Trust me, the feedback is far more useful than it will feel at the time.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=44168a7570b8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What Is Architecture?]]></title>
            <link>https://medium.com/@yrizos/what-is-architecture-68f00a77b664?source=rss-11268a56bad5------2</link>
            <guid isPermaLink="false">https://medium.com/p/68f00a77b664</guid>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[Yannis Rizos]]></dc:creator>
            <pubDate>Mon, 02 Mar 2026 00:00:38 GMT</pubDate>
            <atom:updated>2026-03-02T13:46:43.599Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="A fork in the road: one path splitting into six branches, representing optionality and the capacity to choose direction." src="https://cdn-images-1.medium.com/max/1024/1*s3nWuEd3QnfqrmaqJlTQJg.png" /></figure><p>The deceptively simple question came at <a href="https://open-conf.gr/">Open Conf</a> last November, when a curious young engineer approached me at the conference’s mentorship corner. We were going to get a fresh cup of coffee when she asked: <strong>What is architecture?</strong></p><p>It should have been easy terrain for someone who has spent years inside the problem, but what came out was a few sentences that gestured at decisions and trade-offs without ever landing anywhere. She nodded in the way people nod when they are being polite to someone who has just disappointed them. Almost four months later, I am still turning the question over, which is either embarrassing or instructive.</p><p>I have decided to treat it as the latter and write up what I owe her.</p><h4>The Short Answer Problem</h4><p>The resistance to a clean answer shows up immediately when you go looking for a definition. The closest thing to a satisfying formulation belongs to Ralph Johnson, one of the four authors of <em>Design Patterns</em>, the book that shaped how the industry thinks about software structure. After all that engagement with the problem, Johnson arrived at something that sounds almost flippant:</p><blockquote><em>Architecture is about the important stuff, whatever that is.</em></blockquote><p>Martin Fowler, who often returns to this line, treats the deliberate vagueness as a feature rather than a bug. The longer I’ve spent on architectural problems, the more I think he is right.</p><p>Whenever I’ve tried to give a more precise version of that formulation, something slips. “Architecture is about structure” works until you notice that a pile of undifferentiated code has structure too, and most of it isn’t architectural. “Architecture is about decisions,” works until you ask which ones count, and where you draw that line depends entirely on context. “Architecture is the decisions that are hard to reverse” is closer, but reversibility is partly a function of how the rest of the system is built, which puts you in a loop before you’ve arrived anywhere.</p><p>I’m not alone in this struggle. The Software Engineering Institute maintains a compiled <a href="https://www.sei.cmu.edu/library/what-is-your-definition-of-software-architecture/">catalogue of definitions</a> across modern, classic, and bibliographic sources, and the fact that such a catalogue exists and keeps growing is itself data. That is not a gap in the literature waiting to be filled.</p><p>It is signal about the nature of the thing.</p><h4>What Architecture Is Not</h4><p>The space left by every failed definition does not stay empty for long. A few specific misconceptions keep filling it, and each one was invited by some shorter version that came before it.</p><p>The first, my favorite, is that architecture is the diagrams. UML, C4 models, whiteboard sessions and ADRs are representations of architecture, and useful ones, but they are not the thing itself. A decision shapes what is possible, what is difficult, and what is effectively ruled out, regardless of whether anyone drew it on a whiteboard or wrote it down. You can tear up the whiteboard. The structural commitment has already been made.</p><p>The second misconception is that architecture is a phase. You do the architecture work, hand it off, and then engineering builds the thing. That model comes from construction, where you can hand off a completed design and step back, but software never reaches a completion state. It keeps changing; the structure that shapes it needs to keep being shaped, and a system left without active tending decays. Entropy is not a metaphor for codebases. It is the normal trajectory of any system that nobody is attending to.</p><p>The third misconception is that architecture lives in a role. One person or a small group owns the structural decisions, and everyone else builds inside them without needing to understand or influence them. This is the most consequential of the three because it concentrates exactly the wrong thing in exactly the wrong place. An architect who owns all the decisions has also insulated themselves from the feedback that would improve those decisions. The engineers closest to implementation are the ones who will live with the consequences, and cutting them out of the process means cutting out the most important signal in the room.</p><h4>Deciding Which Tension to Accept</h4><p>Clearing those misconceptions away is useful, but it still leaves the original question open. What I’ve found myself reaching for, when people push past the misconceptions and ask what architecture actually is, is this:</p><blockquote><em>The practice of deciding which tensions to accept and which to release.</em></blockquote><p>Every structural decision trades something: consistency against availability, deployability against performance, team autonomy against system coherence, and there is no configuration that resolves all of these simultaneously.</p><p>If you think you’ve found something without a trade-off, you just haven’t found it yet. Nobody opts out.</p><p>The right trade-off is always context-specific. The skill is not knowing the right tension to accept in the abstract but recognizing which tensions a specific context can absorb, which ones will compound painfully over time, and being deliberate about the choice rather than stumbling into it.</p><p>That relocation is the point. As the old adage goes, complexity cannot be destroyed, only relocated. The architect’s job is to decide where it lives and why that location is better than the alternatives, and no short answer can carry that much context without losing most of what matters.</p><h4>The Organization Is the Architecture</h4><p>One of the things it loses almost every time is the organizational dimension, and that loss is not trivial. Any definition of architecture that stops at the technical is incomplete. In 1968, Melvin Conway made an observation that reads almost like a complaint about a frustrating project: any organization that designs a system will produce a design whose structure is a copy of the organization’s communication structure.</p><p>This may be hard to believe today, but Harvard Business Review actually rejected the paper (for lack of evidence). Decades later, a <a href="https://www.hbs.edu/faculty/Pages/item.aspx?num=32217">Harvard Business School study</a> confirmed exactly what Conway described, and subsequent research at MIT, the University of Maryland, and Tampere University of Technology validated it independently.</p><p>Conway illustrated the dynamic with a story from a compiler project he assigned to eight engineers, five to COBOL and three to ALGOL. Nobody decided how many phases each compiler would have, yet the COBOL compiler ended up with five phases and the ALGOL compiler with three. The structure of the output matched the structure of the team that built it, as an unintended emergent outcome, without anyone planning it.</p><p>If you’ve spent time inside a large engineering organization and wondered why the system looks the way it does, that story will feel less surprising than it should. The uncomfortable version of the observation is that the relationship runs in both directions. The organization shapes the system, and then the system shapes the organization. Teams form around modules, and modules persist because teams formed around them. Technical and organizational concerns co-evolve in ways that make it impossible to cleanly separate them, which is another reason any short definition falls apart. It leaves out half of what is actually happening.</p><h4>Separating Decision from Construction</h4><p>That missing half also reshapes how we need to think about the architect’s role. The broken metaphor at the center of how the field thinks about the architectural role is the building architect: design first, hand off to construction, step back.</p><p>The word itself comes from the Greek <em>arkitekton</em>, meaning chief builder, and the original was not a separate designer standing apart from construction. The chief builder was the most skilled person on the site, someone who understood the full problem from the inside. The software industry borrowed the building architecture metaphor wholesale and quietly erased that origin, replacing it with a designer insulated from consequence.</p><p>Erik Dörnenburg identified this as a <a href="https://erik.doernenburg.com/2014/12/new-recording-of-architecture-without-architects/">structural information problem</a>, not a cultural one. When the decision-maker is systematically insulated from the feedback loop that would otherwise correct bad choices, the design drifts from the reality it is supposed to serve. The distinction Dörnenburg draws is between being aware of consequences and having to live with them, and that gap is where architectural decisions quietly degrade. The moment you separate design from construction, you are separating decision from consequence.</p><p>This leads to a formulation that still surprises people when they hear it:</p><blockquote><em>An architect’s value is inversely proportional to the number of decisions they make.</em></blockquote><p>The goal of architectural leadership is to build the capacity for good structural decisions to happen across the teams doing the work, not to own those decisions permanently. This often gets misread as architecture without accountability, which couldn’t be further from the truth. It requires far more architectural maturity, not less, because teams need to maintain decision records, argue trade-offs honestly, and hold themselves to a standard.</p><p>The concept only works where that maturity exists, and building that maturity is itself one of the architect’s main jobs.</p><h4>The Elevator and the Engine Room</h4><p>What that job looks like across an entire organization is something Gregor Hohpe captures in a <a href="https://martinfowler.com/articles/architect-elevator.html">metaphor</a> I’ve returned to more than almost anything else in this field. Large organizations are tall buildings. The IT engine room is in the basement: the systems, the infrastructure, the code. The executive penthouse is at the top: the strategy, the resourcing decisions, the market bets. Between them are floors of management, and each floor is a translation layer where information degrades as it moves in either direction, telephone game dynamics at the organizational scale. The architect’s job is to <em>ride the elevator</em>, carrying meaning intact in both directions across those translation layers.</p><p>I run an <a href="https://esilva.net/amet">Architecture Modernization Enabling Team (AMET)</a> at Epignosis, and this is what the work actually looks like in practice. The problems that determine whether a modernization succeeds are not purely technical. They are questions about which teams have capacity for which changes, how organizational constraints shape what sequences of work are even possible, and where leadership understanding needs to deepen before a technical choice can be made safely.</p><p>Architecture that stays in the engine room is working with half its inputs. Hohpe puts it plainly:</p><blockquote><em>Excessive complexity is nature’s punishment for organizations that are unable to make decisions.</em></blockquote><p>Architecture is also about options, the right to defer a decision while locking in key parameters. In volatile conditions option value increases, and a system locked by deep coupling has had its options foreclosed. Modernization, in this framing, is not paying off the past. It is rebuilding the capacity to choose.</p><p>That framing also redefines what an enabling team is for. An enabling team exists to build capability in the teams doing the product work, not to own the work permanently.</p><p>The AMET model applies this logic specifically to modernization, as a bell curve of involvement that increases as capability is built and decreases as teams internalize it, until the enabling team eventually dissolves. That lifecycle is not the failure mode. The failure mode is an enabling team that never dissolves because it keeps doing the work instead of transferring the capacity.</p><p>There is a second failure mode that gets less attention, which is the team that dissolves before the capability transfer is genuine. The downslope of the bell curve only resolves correctly when the skills and confidence are actually there, and premature dissolution looks like success until the teams are on their own and discover what they did not actually internalize.</p><p>Both these failure modes point at the same thing from different directions: architecture done well is partly an exercise in making itself unnecessary. That is not something you can fit into two sentences without losing everything that makes it true.</p><h4>The Foundation and What It Enable</h4><p>What it makes possible is the part of the argument that gets framed backwards almost every time I hear it.</p><p>The common version treats modernization as competing with innovation, time spent on the foundation is time not spent building new things, and every sprint on the former feels like something stolen from the latter.</p><p>What this misses is that a system that has not been modernized does not just move slowly. It actively constrains which questions engineers are allowed to ask, and when every change requires deep knowledge of how the system currently holds together, the mental load shifts from “what should we build?” to “what can we build without breaking everything?” That is not a resource problem. It is a cognitive constraint that narrows the product imagination of the entire organization.</p><p>What modernization actually enables is <em>optionality</em>: the capacity to change direction without foreclosing the future, to experiment in one slice of the system without risking another, to run multiple hypotheses simultaneously because the boundaries are clean enough to hold them.</p><p>The features you could not build on the old foundation leave no trace, and nobody wrote them on a roadmap. The innovation that never happened is invisible, which is precisely why modernization is chronically undervalued: <strong>its benefits are counterfactual, and counterfactuals do not appear in sprint reports.</strong></p><h4>The Question Persists</h4><p>The same invisible cost applies to the question itself. An engineer without language for what architecture is will still make structural decisions, and that gap accumulates silently, below the threshold of any report, in exactly the same way as the features that never got built.</p><p>Which brings me to the part where I go against everything in this article and add to the pile:</p><blockquote><em>Architecture is the practice of maintaining the conditions under which better decisions remain possible.</em></blockquote><p>You can probably drill more holes in it than in most short definitions. But it happens to be the one I <em>like</em> the most, and the one I wish I had at the ready four months ago. It would not have been a <em>satisfactory</em> answer, of course.</p><p>But it might, just might, have saved me from that polite nod.</p><p><em>Originally published at </em><a href="https://blog.talentlms.io/posts/what-is-architecture/"><em>https://blog.talentlms.io</em></a><em> on March 2, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=68f00a77b664" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Sentience to Performance]]></title>
            <link>https://medium.com/@yrizos/from-sentience-to-performance-8abe14219cc0?source=rss-11268a56bad5------2</link>
            <guid isPermaLink="false">https://medium.com/p/8abe14219cc0</guid>
            <category><![CDATA[star-trek]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Yannis Rizos]]></dc:creator>
            <pubDate>Mon, 12 Jan 2026 09:29:06 GMT</pubDate>
            <atom:updated>2026-01-12T09:29:06.290Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="Abstract painted figure transitioning from human-like form seeking recognition on the left to geometric performance-focused forms on the right. Represents the shift from questions of AI consciousness and personhood to performance metrics and tools." src="https://cdn-images-1.medium.com/max/1024/1*XrMcPqH6Igt9gh3FMwGi6g.png" /></figure><p>I had a bit of time between Christmas and New Year’s, and I watched a few <em>Star Trek: The Next Generation</em> episodes. And by a few, I mean more than I’m comfortable admitting. I hadn’t watched TNG since before the generative AI wave, and something about Data felt different. Not the character himself, but the questions he represented.</p><p>Data spent seven seasons pursuing what seemed like a central question: could a machine become enough like us to count as one of us? He painted. He composed music. He kept a cat. He formed friendships and tried to understand humor. The show treated his journey toward humanity as the natural arc of advanced AI. If you built something intelligent enough, it would want to be human, and we would need to decide whether to accept it as such.</p><p>Watching those episodes now, that entire framing feels like archaeology. We built systems that scored well and shipped well, and it turned out that the question Data embodied was never the one we needed to answer.</p><h4>The Prelude to Personhood</h4><p>When I was a kid, Data was how I thought about AI. Not because the show predicted neural networks or anything that technical. He just made the whole thing feel concrete. An android smart enough to serve on a starship bridge would naturally want recognition as a person. The show never questioned this premise. Neither did I.</p><p>Another favourite, Isaac Asimov’s “<em>The Bicentennial Man,</em>” operated from the same assumption, only more explicitly. Andrew Martin starts as a household robot, a roomba on steroids, who discovers creativity and the desire for recognition. He spends decades pursuing legal status as a human being, accepting mortality so society will finally see him as a man rather than property. The story culminates in his death being recognized as the death of a person, not the deactivation of a machine. Both stories treat capability as the prelude and recognition as the inevitable fight. Intelligence implies personhood. Personhood requires the desire to belong.</p><p>The logic seemed airtight. Once that premise is accepted, the rest follows. Building sufficiently advanced AI would force us to answer hard questions. Does consciousness emerge from complexity? What separates persons from sophisticated tools? Data serving on a starship bridge meant confronting those questions. Andrew cleaning a household meant the same thing. The technical problems would get solved, and then the real challenge would begin.</p><h4><strong>A Test for Thinking Machines</strong></h4><p>Alan Turing gave us one answer to that recognition problem. His 1950 paper “<em>Computing Machinery and Intelligence</em>” proposed a deceptively simple test: if a machine could participate in a conversation well enough that a human observer couldn’t reliably distinguish its responses from those of another human, we should grant that the machine was thinking. The elegance of the Turing Test was in sidestepping metaphysics entirely. Instead of debating what consciousness really is, Turing suggested we could evaluate intelligence through observable behavior.</p><p>The test embedded an assumption that stayed with us for decades. Human-like performance in conversation became the benchmark for intelligence. If you could fool someone into thinking you were human, you had crossed a threshold that mattered. The test didn’t require the machine to want anything or feel anything. It just needed to produce the right outputs in the right context. But it still pointed toward human-like interaction as the thing worth measuring.</p><h4><strong>When Performance Became Enough</strong></h4><p>I remember when Deep Blue beat Kasparov in 1997. It felt like a threshold moment. <em>A machine had beaten the best human player</em>. When that happened, it should have triggered the questions that Data and Andrew made central. Did Deep Blue want to win? Did it experience satisfaction? Should we care?</p><p>Nobody seriously argued it should be treated as a person. The machine beat the world’s best human player, but no one suggested it deserved rights or recognition. Deep Blue did something useful. That was enough. The reaction was scoreboard-based. The system didn’t need to present as a mind. It needed to win. The evaluation harness was performance, not personhood.</p><p>AlphaGo defeating Lee Sedol in 2016 followed the same pattern. The victory generated excitement about what AI could accomplish, not anxiety about what we owed it. Nobody worried about whether AlphaGo experienced pride or frustration during the matches. The system solved a problem humans found difficult. The personhood question never surfaced.</p><p>These victories showed something important about how AI evaluation had shifted. We stopped asking whether machines could think like us and started asking whether they could deliver outputs we cared about. The benchmarks that mattered measured performance on tasks, not similarity to human cognition or behavior. What we tested became what we decided mattered.</p><h4><strong>The Incentive Structure</strong></h4><p>Better benchmark scores led to more citations, more funding, and more talent. Better product performance led to more users, more revenue, and more iteration capacity. Benchmarks and product requirements pushed AI development in a specific direction because they connected directly to resources. These feedback loops pointed toward capability, not consciousness. The industry optimized for what could be measured and sold.</p><p>This wasn’t a philosophical decision. You can A/B test task completion rates. You can’t A/B test consciousness. The personhood question retreated because it couldn’t fit into the harnesses that determined what got built and what got funded. When you evaluate a language model, you measure how well it answers questions. When you deploy computer vision, you track accuracy and latency. The only metrics that survive are the ones that show up in a paper, a demo, or a contract renewal.</p><h4><strong>What We Traded</strong></h4><p>Data feels like a relic now. He represents a version of the future where the personhood question never goes away. Build something smart enough, and you have to deal with what it wants. In that future, building something smart enough to serve on a starship bridge means building something that wants to be recognized, something that pursues acceptance, something that experiences its own existence. The technical problems and the philosophical problems travel together.</p><p>We built something different. We built systems that deliver capability without requiring any account of inner life. Current models pass acceptance tests by demonstrating they can complete tasks within specified constraints. The evaluation rubric asks whether the output is correct, whether the latency is acceptable, and whether the system scales. It doesn’t ask whether anything is happening inside. We stopped needing answers to consciousness questions to deploy useful systems.</p><p>For decades, researchers and technologists imagined AI development would force us to confront questions about machine consciousness and rights. We ended up with systems that don’t demand recognition, so product teams can treat them as tools and never be forced into the legal and moral fight that Andrew Martin made inevitable. We also built systems whose limitations are harder to see because they perform well on the metrics we chose to track. The things we didn’t measure might matter later. But right now, they don’t appear in any rubric.</p><h4><strong>Still Watching</strong></h4><p>I finished those episodes, and I’m still not sure what to make of them. Data’s quest for humanity reads differently when you know how AI evaluation actually developed. The show treated personhood as the natural destination of intelligence. We built systems that scale in capability without converging toward anything Data would recognize as his own goals.</p><p>Maybe future systems will revive those questions. Maybe we’ll build something that pursues recognition. But that’s not the trajectory we’re on. The performance keeps improving. The consciousness never arrives.</p><p>Data wanted to be human. We built tools that perform tasks.</p><p>Only one of those futures shipped.</p><p>PS: If you haven’t seen TNG and want somewhere to start, I’d wholeheartedly recommend Season 2, Episode 9, <em>The Measure of a Man</em>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8abe14219cc0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Boundaries Against the Machine]]></title>
            <link>https://medium.com/@yrizos/boundaries-against-the-machine-4a2310b42981?source=rss-11268a56bad5------2</link>
            <guid isPermaLink="false">https://medium.com/p/4a2310b42981</guid>
            <category><![CDATA[legacy-systems]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[domain-driven-design]]></category>
            <dc:creator><![CDATA[Yannis Rizos]]></dc:creator>
            <pubDate>Mon, 08 Dec 2025 00:00:37 GMT</pubDate>
            <atom:updated>2025-12-08T09:43:49.460Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="Two abstract painted figures seated at a desk studying multiple maps with boundaries and routes on a warm background" src="https://cdn-images-1.medium.com/max/1024/1*Hl6basbW72EzSp98TX4pHA.png" /></figure><p><strong>DDD Europe 2020, Amsterdam.</strong> For a COVID-era hire like me, this was the first time meeting several colleagues in person whom I had been working with daily for months. I kept noticing how familiar everyone sounded and how unfamiliar they looked. An odd sense of delayed recognition. We had paired on code over Google Meet, argued about bounded contexts in Slack, but never shared the same room. The talks, the workshops, the hallway conversations with practitioners who had been doing this for years. We absorbed everything we could.</p><p>This was not a one-off. Over the next five-plus years, Epignosis doubled down on more conferences, internal training programs, external consultants, workshops, books, the works. The investment was significant. The business case was clear. Align our code with our business. Make the codebase maintainable as we scale. Enable domain experts and developers to speak the same language.</p><p>What we did not anticipate five years ago, in that Amsterdam conference hall, was that we were also preparing our codebase for a future where AI would help us write it.</p><h4>What We Built</h4><p>The first fruits came when we built the new TalentLMS API. This is where Domain-Driven Design stopped being conference theory and became operational practice. We established Ubiquitous Language with domain experts. I remember the shift when conversations with product became faster because we had finally stopped translating ideas back and forth. No more translation layer between what product teams said and what engineers built.</p><p>We introduced Value Objects to replace primitives. A CourseStatus is a CourseStatus with its own validation and behavior. Some engineers hesitated at first because what we were now calling <a href="https://refactoring.guru/smells/primitive-obsession"><em>primitive obsession</em></a> had been the norm for years. That hesitation faded once the constraints started catching real issues. No more passing around strings and hoping they were the right kind of string.</p><p>The Anti-Corruption Layer became the cornerstone of our refactoring strategy. We were building new code alongside what was, at the time, a 12-year-old system. We could not afford to let old assumptions bleed into the new model. I could feel the team relax once they realized the new model would stay protected from old assumptions. The ACL created a boundary, a translation layer that let us move forward without being dragged backward by legacy constraints.</p><p>Legacy systems demand clarity at every layer. When domain experts and engineers speak different languages, features get built wrong. When boundaries blur, technical debt compounds. At our scale, DDD was not optional. It was operational necessity.</p><p>After the API project, we restructured the codebase around domain concepts. We moved from a technical organization to a domain one. Now you do not just know where the models, the views, and the controllers are. You know where the <em>Learning Paths</em> are. Where <em>Talent Library</em> lives. Where to look for <em>Reports</em>.</p><h4>How AI Reads It</h4><p>Today, when I ask AI to add a feature to <em>Notifications</em>, it enters the module as if it already understands the territory. It reads the surrounding files, forms a picture of the local concepts, and uses those patterns to shape its first draft. The result is not perfect, but the model moves through the module with a level of confidence that only appeared once the structure became consistent.</p><p>AI tools work with limited context. Your current file plus nearby files. This turns domain-based organization from nice to have into critical. When AI is working in the Notifications module, the files it can see are notification concepts, not random controllers. Proximity becomes a semantic relationship instead of accidental collocation.</p><p>AI consumes our DDD structure through multiple channels. File and directory names reflect domain concepts. When AI scans the Notifications module, it sees how we handle trigger conditions, execution schedules, and result tracking. Architectural Decision Records document why certain boundaries exist and what alternatives we considered.</p><p>Value Object type signatures make constraints explicit in method signatures. When AI sees a function that takes NotificationsTitle instead of a string, it recognizes a constraint. The Ubiquitous Language we established means the model encounters terms that carry domain meaning, not generic technical jargon.</p><p>The Anti-Corruption Layer shows AI where boundaries are. It will not couple new feature code directly to legacy database schemas. The ACL is a boundary, a wall you cannot walk through without noticing.</p><p>The first time AI added code that matched the existing module structure, it felt like the model had finally learned the shape of our system. That was the moment when the link between our boundaries and the model’s output stopped being theoretical and became visible in daily work.</p><h4>Was It Worth It?</h4><p>DDD is not free. Introducing Value Objects means wrapping primitives. Defining aggregates means thinking hard about consistency boundaries. Building an Anti-Corruption Layer means accepting the overhead of translation between old and new.</p><p>In a greenfield project, you can build with DDD from day one. In a legacy codebase, you are retrofitting. You are making incremental changes while keeping the system running. Every change needs careful migration. Every boundary you introduce might break something. Restructuring a codebase around domains when you have more than a decade of technical organization is months of work.</p><p>Maximalists argue we should wait for better models. Models are improving fast. By the time you have spent six months on DDD, maybe AI will not need that structure anymore. Maybe it will figure things out. These are not unreasonable positions.</p><p>But TalentLMS is not a prototype; it is not something you build at a <a href="https://www.starttech.vc/blog/2025/from-ancient-theater-to-modern-hackathlon/">3-day hackathon</a>. It serves more than 20 million users. That means edge cases accumulated over more than a decade that are not in any training data. Business logic that reflects real-world complexity, not textbook examples. Performance optimizations that look odd but exist because a specific query pattern was crushing the database back in 2014. Regulatory requirements across different countries. Integrations with dozens of third-party tools, each with its own quirks. Data migrations that took months to plan and execute.</p><p>AI cannot hold this in its context window. Even the largest models. You cannot fit years of accumulated decisions, trade-offs, and reasons for odd behavior into a prompt. Seeing AI miss a detail that every senior engineer at TalentLMS knew by heart reminded me how much of our system lives outside documentation. Kent Beck frames it clearly in <a href="https://tidyfirst.substack.com/p/programming-deflation">Programming Deflation</a>:</p><blockquote><em>In a world of abundant cheap code, what becomes scarce? Understanding. Judgment. The ability to see how pieces fit together. The wisdom to know what not to build.</em></blockquote><h4>What We Are Seeing</h4><p>Features that would have taken days now take hours. AI-generated code fits our architecture more consistently. I cannot tell whether the improvement comes from our structure, better prompts, or rapid model progress. I only know the change is visible in daily work.</p><p>Structure that helps humans navigate complexity seems to help machines navigate it too. Whether that is causal or correlation, we will know in the near future. For now, we are paying close attention.</p><p>But the shift is real. When AI writes the boilerplate, what remains are the decisions that matter. Where boundaries go. What invariants hold the system together. How capabilities compose. Which trade-offs we are willing to accept and why.</p><p>In the good old days, we spent mental energy on low-level questions. How to implement a validation. How to write a specific query. With AI, that energy can be reserved for higher-level reasoning. What invariants an aggregate must protect. Where a capability belongs in the architecture. Same mental load, different altitude. More time on structure. Less on mechanics.</p><p>At 100 million requests per hour, architectural decisions compound. A poor boundary creates operational problems. A missing invariant risks data integrity. AI can help you move faster, but only if your architecture can guide it. Without that, AI only helps you make mistakes faster.</p><h4>Five Years Later</h4><p>Standing in that Amsterdam conference hall, we were learning DDD to build better software. The investment was about aligning code with business language, about creating boundaries that made sense, about sustainable complexity management.</p><p>Today, that same investment pays dividends we never anticipated. Our domain modules. Our explicit boundaries. Our Ubiquitous Language. The Anti-Corruption Layer that keeps old assumptions from bleeding into new code. None of it was built with AI in mind, yet all of it matters for AI effectiveness.</p><p>I look back at that conference trip now with a sense of quiet irony because none of us imagined what those early choices would enable. Those workshops and late-night debates about aggregate boundaries were not only about maintainability. They were shaping the maps that modern development tools now rely on.</p><p>Not a bad return on investment for a conference trip.</p><p><em>Originally published at </em><a href="https://blog.talentlms.io/posts/boundaries-against-the-machine/"><em>https://blog.talentlms.io</em></a><em> on December 8, 2025.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4a2310b42981" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Super Secret Project That Probably Won’t Happen]]></title>
            <link>https://medium.com/@yrizos/super-secret-project-that-probably-wont-happen-20702be7357b?source=rss-11268a56bad5------2</link>
            <guid isPermaLink="false">https://medium.com/p/20702be7357b</guid>
            <category><![CDATA[mentorship]]></category>
            <category><![CDATA[engineering-leadership]]></category>
            <category><![CDATA[engineering-management]]></category>
            <dc:creator><![CDATA[Yannis Rizos]]></dc:creator>
            <pubDate>Mon, 10 Nov 2025 00:00:59 GMT</pubDate>
            <atom:updated>2025-11-10T08:02:38.345Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="Abstract painted composition showing transformation from uncertainty to structure. Fragmented organic forms on the left transition through a gestural path or bridge to organized geometric shapes on the right. Muted earth tones with visible brushwork and paint texture throughout. Fine art aesthetic with generous negative space." src="https://cdn-images-1.medium.com/max/1024/1*-7lTDhV9-6k1-tqw8Wp8Tg.png" /></figure><p>In May 2023, I sent an email to a handful of engineers inviting them to discuss a “<em>super secret project that probably won’t happen</em>.” Yes, that was the actual meeting title. I figured if I was asking people to bet time on something uncertain, I should at least be honest about the odds.</p><p>25 mentorship pairs later, that meeting turned into the most unexpectedly durable thing I’ve built at Epignosis. I’m still not entirely sure why it worked.</p><h4>The Gap</h4><p>At the time, Junior engineers at Epignosis only knew their immediate squad. Maybe 5 to 7 people in a 200-person company. After the pandemic, teams had drifted into their own orbits and remained there. The casual spillover that used to happen in offices was just gone. These engineers had no idea how other teams worked, what they were building, or who to even ask when they hit something outside their area. The problem wasn’t that they lacked skill. They lacked context.</p><h4>Four Skeptics and a Plan</h4><p>I pitched something simple in that first call. Pair junior engineers across products and functions. TalentLMS padawan with an eFront mentor, and vice versa. An engineer interested in backend work with someone from DevOps. Not technical coaching about their specific codebase, but something harder to name. <em>Engineering socialization</em>, maybe. The stuff that happens when people occupy the same physical space but vanish in distributed work.</p><p>Someone spoke up immediately. I don’t remember who anymore, but I remember this: they were enthusiastic about the idea and skeptical I’d actually pull it off. Penelope, Thrasos, Christos, and Dimitris all volunteered to be the first mentors. Their skepticism wasn’t about the concept. It was about execution. They were feeling the siloing problem too, and they thought breaking it down would take massive effort.</p><p>Without them stepping into something uncertain before it was proven, the program would have stayed a document in a folder somewhere. Pushed down the priority list when something urgent arrived, one more thing that seemed reasonable at the time but never quite happened.</p><h4>Six Sessions, Three Months</h4><p>We launched in June 2023 with a new cohort of interns. The format was simple on purpose. An hour every 2 weeks for 3 months, 6 sessions total. I matched the duration to the internship window partly because research says the first 90 days determine whether someone succeeds, but mostly because I didn’t want an open-ended commitment. Open-ended things drift. Boundaries create focus.</p><p>I insisted on one thing: document your meetings. Not for oversight, but to help pairs track their own conversations. In time, some pairs shared sanitized versions of their notes. Those became the best onboarding material new mentors could ask for. Actual conversations, actual topics, actual problems that came up. No scorecards, no frameworks, no evaluation rubrics. Just enough structure to prevent drift without turning the whole thing into theater.</p><h4>The Conversations</h4><p>One mentee showed up to their second session worried they were underperforming. Not on any specific task. Just a general anxiety about not being good enough, not learning fast enough, not contributing enough. The mentor shared their own story about imposter syndrome. They kept coming back to that thread over the next few sessions while also covering technical stuff. How do you tell the difference between actually underperforming and just feeling like you are?</p><p>By session 5, they’d covered the structured agenda and used the final meeting to just talk. They met in person that time. Career paths came up, and what actually matters long-term, and work-life balance. I’m curious how that conversation resolved, but I’m not part of these sessions. I only see what pairs choose to document.</p><p>Another pair spent an entire session mapping the org chart. Not the official one, the real one. Who actually makes architecture decisions? Who do you talk to when you need infrastructure help? Who knows why certain systems exist the way they do? This stuff doesn’t live in any documentation. It shifts every time someone changes roles or teams are reorganized.</p><p>A third pair had a 20-minute detour in their second session about falsehoods programmers believe about names. Edge cases, international character sets, all the assumptions we make that blow up in production. By session 4, they were talking about how to give code review feedback that actually helps without making someone feel terrible. The mentee walked away with a plan to raise task ambiguity in their team’s next retrospective.</p><p>The documentation turned out to serve a double purpose I didn’t fully anticipate. It helps pairs track their own evolution, sure. But it also creates institutional memory without needing someone to formalize it. New mentors read notes from previous pairs and see what’s actually possible. One pair investigated architecture testing tools and decided none of them fit. That documented failure is now a useful context for anyone else hitting the same question.</p><h4>Twenty-Five Pairs Later</h4><p>We’ve run 25 mentorship pairs at this point. Some of the past mentees are now mentors themselves. I never imagined the program would endure long enough for that to happen. We’ve expanded beyond interns to include all junior hires. The cross-product and cross-functional pairing continues. Those first 90 days still feel like the window that matters most.</p><p>The program has been valuable for the mentors, too. They practice one-on-one skills in a low-stakes environment, an early step in their leadership path. Explaining complex systems simply is harder than it looks. They get better at it. They remember what it’s like to be new, which helps them improve their own team’s onboarding. Mentee questions expose them to parts of the codebase they don’t usually touch. Gaps in documentation that experienced people don’t notice anymore suddenly become obvious.</p><p>Cross-product pairing creates what I later found out researchers call weak ties. An intern who spends 6 hours over 3 months talking to a mentor from another product builds a bridge that wouldn’t exist otherwise. Later, when they need help with an integration problem or want to understand how another team handles something, they have an actual person to ask. <em>Conway’s Law always in motion.</em></p><h4>Deliberately Incomplete</h4><p>Every choice here involved trade-offs I couldn’t fully resolve. The 3-month window fits the critical adjustment period, but also just matches how long interns stay. Cross-product pairing builds bridges but sacrifices domain-specific technical mentorship. Light structure keeps people engaged but risks inconsistent execution. I chose these parameters deliberately, but I wouldn’t claim they’re universally right. They work for our specific context.</p><h4>From Super Secret Project to Standard Practice</h4><p>From “probably won’t happen” to standard practice took a few months, far less time than I thought it would. Low expectations helped. I didn’t promise transformation or measurable outcomes. The engineers who volunteered as first mentors turned that uncertain beginning into something that stuck.</p><p>Now it’s just how we work. New hires get matched. Past mentees become mentors. The first mentors were skeptical I’d pull it off, and I understand why. Programs like this usually collapse under their own complexity or drift when they ask too much. But they were wrong about one thing. Breaking down silos didn’t take massive effort. It took a meeting with a ridiculous title, a handful of people ready to try something uncertain, and the discipline to keep it simple.</p><p>Sometimes that’s enough.</p><p><em>Originally published at </em><a href="https://blog.talentlms.io/posts/super-secret-project-that-probably-wont-happen/"><em>https://blog.talentlms.io</em></a><em> on November 10, 2025.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=20702be7357b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Ancient Theater to Modern Hackathlon]]></title>
            <link>https://medium.com/@yrizos/from-ancient-theater-to-modern-hackathlon-e4ea2199faeb?source=rss-11268a56bad5------2</link>
            <guid isPermaLink="false">https://medium.com/p/e4ea2199faeb</guid>
            <category><![CDATA[accessibility]]></category>
            <category><![CDATA[mentoring]]></category>
            <category><![CDATA[hackathons]]></category>
            <dc:creator><![CDATA[Yannis Rizos]]></dc:creator>
            <pubDate>Tue, 23 Sep 2025 13:41:23 GMT</pubDate>
            <atom:updated>2025-10-10T11:55:30.686Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="Abstract painted composition showing a bustling hackathon scene with teams working on laptops, surrounded by robotics displays. Heavy brushstrokes and textured paint create abstract forms suggesting collaborative work, technical discussion, and innovation in a convention center setting. Muted earth tones with expressive paint application." src="https://cdn-images-1.medium.com/max/1024/1*waRGumcp19WiqLLtXfqszg.png" /></figure><p>Exhausted.</p><p>That single word captures everything after 3 days at the {Re}Solve Hackathon by Open at the Thessaloniki International Fair 2025. The kind that comes from being fully present, from watching builders turn ideas into working prototypes, and from seeing teams create things they had not thought possible. The tiredness felt earned, interesting, fun, and at times humbling.</p><p>My alarm went off at 6 am on Friday. I arrived at the airport by 7:30 am, landed in Thessaloniki at 9:30 am, and entered the venue by 10:15 am. By Sunday night, I was back home in Athens. A whirlwind weekend of a thousand freddo espressos. And I was there only to observe and guide. I can’t even begin to imagine how the actual builders felt.</p><h4>From Ancient Theater to Modern Fair</h4><p>The path to this exhaustion began in the most unlikely place. August 8th, late evening, walking through the parking lot at Epidaurus after watching Euripides’ Andromache with my wife and daughter. The ancient stones were behind us, the summer air still warm from the performance. That is when Pantelis Stakias appeared out of nowhere.</p><p>Pantelis is one of the driving forces behind Open Conf and the Open Hackathon. I had participated in the second Open Hackathon back in June as a primary mentor. When we crossed paths that night, he launched into a rapid-fire explanation. He and Elias Tsaldaris were organizing a hackathon at TIF 2025 in my hometown, Thessaloniki, and they wanted me back. The twist made it serendipitous. Elias had been a participant in the June hackathon, part of a team I had mentored. Now he was helping organize the next one.</p><p>I had missed a call from Pantelis earlier that week, so without this chance encounter, the invitation might never have reached me. My wife, standing beside me, could already tell what my answer would be before I even said it.</p><h4>Perfect and Terrible at Once</h4><p>Pavilion 17 turned out to be both perfect and terrible for a hackathon. Perfect because we were sharing the space with several universities showcasing their work in engineering and robotics. Students demonstrated robotic arms, racing cars, drones, and AI experiments. The air buzzed with activity.</p><p>Terrible because the Fair is massive and packed with people. The noise, the distractions, and the constant flow of visitors discovering what we were doing created relentless interruptions. We were outliers. Most exhibitors were there to showcase products or services. We were there to build.</p><p>Visitors would stop, confused about what they were witnessing. “What is this?” they’d ask, watching teams hunched over laptops, deep in conversation about blockchain trust mechanisms and accessibility solutions. “We’re building the future,” someone would answer. Exaggeration? Maybe. Maybe not.</p><p>Fortunately, the organizers had managed to find quieter corners where teams could focus when they needed to escape the chaos. Nevertheless, the energy of the larger space was infectious.</p><h4>Pre-Pitching and Meeting Builders</h4><p>Friday was pre-pitching day. At the June hackathon, I was still finding where I could help. By September, the questions that mattered had become clearer. Does the team have the right mix of skills? Is the scope realistic for 3 days? Are they solving a real problem or just a technical demonstration? I had begun to trust my instincts about what works.</p><p>3 teams were assigned to me as their primary mentor. I worked with them to prepare for presenting their concepts to the larger group, focusing on scope, team skills, originality, feasibility, and communication. I also managed to spend time with other teams. Time was limited, but I valued every chance to connect with builders.</p><p>One team stood out early. GenZ, an all-women group with no engineering background. Even for experienced developers, a hackathon takes nerve. They chose to step in with a strong idea: an app to help blind people apply makeup. A practical answer to an everyday challenge faced by millions.</p><p>With support from fellow mentor Dimitris Angeloukos, they vibe-coded a working prototype in hours. Watching them move from hesitant first-timers to confident presenters showed how AI-assisted coding closed the gap between idea and implementation and made domain knowledge outweigh coding expertise.</p><h4>The Accessibility Panel</h4><p>Saturday was quiet because builders were deep in focus. You could feel the intensity as teams moved from concept to code, from sketches to working demos. The day when ideas either came together or fell apart under pressure.</p><p>The highlight was an accessibility panel excellently moderated by Grigoris Lemonis. Participants included myself, Nikos Apostolidis (a seasoned web developer and digital accessibility expert), Theodoros Iliadis from team Vitreous, and George Nasiopoulos from the Interoperability Masters team that had won the June hackathon.</p><p>Nikos made a point that tied back to what was happening around us. We need to stop assuming what people who will use our solutions can and cannot do. Instead, we should include them from the early stages and make them part of all core decisions. This is especially true for people with disabilities, who are more often than not excluded from the decisions.</p><p>I followed up, saying this was my main takeaway from the Open Hackathon and a key reason I wanted to participate in this one. The organizers had intentionally included people with disabilities as judges, mentors, and subject matter experts. Teams had real opportunities to get feedback from the people who would actually use their solutions.</p><p>We discussed approaching accessibility as lived experience rather than just compliance checklist thinking. The difference is profound. Compliance asks whether minimum requirements are met. Lived experience asks whether the solution improves daily life. That same thought echoed what my colleague Thanassis Parathyras had captured in his <a href="https://www.starttech.vc/blog/2025/hack-for-fun-and-a-noble-purpose/">blog post about the June hackathon</a>:</p><blockquote><em>It’s easy to talk about accessibility in abstract terms. But being in a space where every idea had a human story behind it, that changed something in me.</em></blockquote><h4>Final Presentations</h4><p>Sunday arrived with palpable excitement. The day we’d find out who won, but more importantly, the day teams would present what they’d built. The teams were showing signs of fatigue, but they were discussing their solutions with each other, sharing insights, and offering help.</p><p>They were competing for the same prizes, but this didn’t stop them from collaborating. I watched teams troubleshoot each other’s last-minute problems and provide feedback on presentations. Competition hadn’t killed collaboration. In my corporate world, competition often creates silos. Here, scarcity thinking was absent. Teams understood that knowledge sharing strengthened everyone.</p><p>While waiting for the presentations to begin, I spoke with a fellow craftsman who had dropped by the Fair. He told me he had to chase down four approvals to get his company’s backing to attend a tech event.</p><p>My story was different. All it took was a Slack message: “Hey, this cool thing is happening. I’d like to be part of it. Can we support it?” The answer came back almost instantly: “Of course!” Travel, accommodation, everything sorted without hesitation. For Epignosis and Starttech Ventures, supporting the tech ecosystem is not an afterthought. It is part of who we are.</p><p>Soon after, the first team took the stage. What followed was a series of projects that showed both imagination and urgency. Some focused on accessibility, from platforms that performed audits and even fixed accessibility issues in real time to gaze tracking apps designed for people with Rett Syndrome. Others explored blockchain, with proposals aimed at pressing issues. A “wallet of trust” to identify and stop scammers. A service positioned as a “universal trust authority” for ethical funding. A platform for real estate micro-investing.</p><p>The judges faced an impossible task choosing the top 3. When the prizes were announced, it was clear there were no real losers. Every team had built something meaningful, gained experience, and formed connections they would not have made otherwise.</p><h4>Building and Mentoring</h4><p>Every meaningful decision that teams made was framed as competing forces. Cost, complexity, adaptability, delivery speed, and sustainability weighed against 3-day constraints. Most teams chose pragmatically: get it working first, worry about elegance later. Dan North’s concept of building “The Best Simple System for Now” in practice.</p><p>But the more interesting architectural challenge was the hackathon itself as a sociotechnical system. Conway’s Law played out in real time as team communication patterns shaped their final solutions. Teams that spent too much time on infrastructure struggled to deliver working demos. Teams that chose familiar technologies over optimal ones shipped faster. Small decisions about team structure and technology choices cascaded into significant consequences by day 3.</p><p>The organizers created boundaries that empowered teams to make local decisions while maintaining overall coherence. Primary mentors provided strategic guidance without micromanaging. Subject matter experts offered specialized knowledge on demand. The structure enabled autonomy while preventing chaos.</p><p>The same principles applied: clear interfaces, loose coupling, high cohesion, and emergent behavior from simple rules. This was systems thinking in action, applied to human creativity rather than software architecture.</p><h4>Coming Home</h4><p>By the time I returned home on Sunday, a minute shy of midnight, the serendipitous journey from Epidavrus to Pavilion 17 felt symbolic. Ancient theater fading into modern invention, if you allow for a slice of hyperbole.</p><p>From June to September, mentoring across two hackathons gave me as much as I gave. The teams taught me as much as I taught them.</p><p>If you’re reading this and wondering whether you should volunteer at a hackathon, my answer is straightforward: do it. Not because you’ll feel good about giving back, though you will. Not because it looks good on your LinkedIn, though it might. Do it because you’ll remember why you fell in love with building things in the first place.</p><p>The tech community thrives because people choose to contribute. Choose to mentor. Choose to share knowledge. Choose to create space for others to build. That choice is available to anyone reading this. The only question is whether you’ll take it.</p><p>The next time opportunity appears in a parking lot, at a conference, or in your inbox, I hope you say yes. The community needs more mentors, more volunteers, and more people willing to support builders. The future is built by people who show up and help others bridge the gap between idea and implementation.</p><p>And sometimes, the most meaningful journeys begin with the most unexpected encounters under ancient stars.</p><p><em>Originally published at </em><a href="https://www.starttech.vc/blog/2025/from-ancient-theater-to-modern-hackathlon/"><em>https://www.starttech.vc</em></a><em> on September 23, 2025.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e4ea2199faeb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Into the Codebase, One Bug at a Time]]></title>
            <link>https://medium.com/@yrizos/into-the-codebase-one-bug-at-a-time-1bc991ce9a07?source=rss-11268a56bad5------2</link>
            <guid isPermaLink="false">https://medium.com/p/1bc991ce9a07</guid>
            <category><![CDATA[engineering-management]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[engineering-leadership]]></category>
            <category><![CDATA[technical-debt]]></category>
            <dc:creator><![CDATA[Yannis Rizos]]></dc:creator>
            <pubDate>Sat, 23 Aug 2025 23:49:43 GMT</pubDate>
            <atom:updated>2025-10-05T21:18:21.192Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="Abstract painted representation of a very small golden idol on a weathered stone pedestal in a desolate ancient temple chamber being reclaimed by forest vegetation, rendered in muted earth tones with heavy brushwork and paint texture, positioned centrally with crumbling temple architecture in the background." src="https://cdn-images-1.medium.com/max/1024/1*TYfJptxGIYybtE0K3OiEHg.png" /></figure><p>The temple was crumbling. I could see that much walking in. No clear maps. No reliable guides. Just a system that worked well enough that no one had bothered to document where the traps were hidden.</p><p>Taking over a new team means making choices about what comes first. Most leaders push for quick wins. Ship a feature. Show value. Build momentum. I did the opposite. I told the team we were stopping feature work for an entire sprint. We would fix bugs, pay down technical debt, and repair what was broken.</p><p>They looked at me like I was insane.</p><h4>Why Repair, Why Now</h4><p>Bug bashes happen all the time. Teams schedule hardening sprints when stakeholders panic or when delivery breaks spectacularly. These are reactive patterns, crisis responses. What I was proposing was different. Strategic. Deliberate.</p><p>I needed to understand two systems simultaneously. The technical one which was opaque and poorly documented. The human one, which was stressed and uncertain after months without clear leadership. Feature work would teach me what the team already knew how to do. Repair work would show me what they avoided, what they feared, and where the real complexity lived.</p><p>Stakeholders noticed immediately. Feature delivery paused for an entire sprint. I didn’t hide it or apologize. I framed repair as onboarding. I was new. I needed to understand the system before making commitments about it. That framing held because I had the authority to make it hold. Someone without that leverage might not have gotten the breathing room.</p><p>The team’s reaction told me something important. Relief. Not frustration. Relief. They felt permission to care about code quality again, something they hadn’t felt in a long time.</p><h4>What the Bugs Told Me</h4><p>The first issue we tackled looked trivial. A third-party integration is failing intermittently. It should have been a day’s work.</p><p>It was unfixable.</p><p>Not because of code complexity. Not because of architectural problems. The team had no sandbox access to the vendor system. They’d been requesting it for months. Nothing had happened. So they’d adapted. Built workarounds. Tested in production. Normalized the broken state so completely that no one had bothered documenting the limitation.</p><p>I asked where this was written down. Nowhere. I asked why no one had escalated. Shrugs. “That’s just how it is.”</p><p>This became the pattern. Real constraints surfaced only under direct pressure. Documentation lied by omission. Design diagrams showed clean boundaries that didn’t exist. Feature work never exposed these gaps because features stayed inside known territory. Bugs dragged us into corners where assumptions broke, and the actual architecture revealed itself.</p><p>One bug cluster pointed at something else entirely. Not technical failures but unclear product decisions. Requirements that had been deferred so long they’d calcified into implicit assumptions. No one had written them down. They existed only as hundreds of small implementation choices scattered across the codebase.</p><p>The system under strain told the truth. Everything else told comfortable stories.</p><h4>What the People Told Me</h4><p>Debugging exposes competence differently than feature work does. I watched how different engineers approached problems. One moved methodically, testing each step before proceeding. Another made rapid changes, hoping something would land. The contrast showed who understood the system’s internals and who was still guessing their way through it.</p><p>Tool choices revealed even more. Some developers reached for logs, metrics, and staging environments. They built understanding from observable data. Others cleared caches and redeployed without investigating what had changed. The system was a black box; they treated it as if it responded to ritual.</p><p>One developer stood out immediately. She always checked git commits and deploy notes before touching anything. Version control as investigative record, not just backup storage. That habit cut her debugging time dramatically while everyone else thrashed.</p><p>A quieter developer surprised me during one session. Her problem-solving approach was careful, systematic, and thorough. Normal feature work would never have made this visible. She gained credibility that carried forward into every subsequent technical discussion.</p><p>Knowledge had pooled dangerously. Every complex question is funneled to the same person. One silo. One bottleneck. The team couldn’t scale like this.</p><p>When someone admitted she didn’t know where to start with a particular issue, I suggested pairing. We debugged together. Fixed the problem. More importantly, we captured what we’d learned. We wrote a test. We added comments. We left a trail.</p><p>This became standard practice. Every fix left something behind. Failing conditions became automated tests. Unclear behavior became documentation. The team started seeing tests and documentation differently. Not overhead. Not process for process’s sake. Immediate value. When yesterday’s test caught today’s regression, the feedback loop closed instantly.</p><h4>What the Repair Cycle Established</h4><p>Taking over a team creates stress. Uncertainty about what will change runs high while everyone evaluates the new leader. Pushing straight into feature work would have spiked that pressure immediately, forcing technical decisions before trust existed.</p><p>Starting with the repair shifted everything. We tackled visible frustrations first. Reduced debt that had been grinding against daily work. Built small wins that people could feel in their own workflows. Confidence grew through shared action, not promises.</p><p>The team’s language changed. “How fast can we fix this?” became “Will this hold?” Quality stopped being something that happened to them and became something they shaped actively.</p><p>Repair wasn’t penance. It wasn’t an admission that previous work had been bad. It was an investment. We were building a foundation for everything that would come after.</p><p>By the end of that sprint, I had context that no documentation could have provided. I understood where confidence lived and where it didn’t. I saw what people avoided. Where they hesitated. What they trusted.</p><p>The real constraints that shaped daily work were mapped. Dependencies that blocked progress. Modules no one dared touch. Missing test coverage. Knowledge silos. None of this appeared in system diagrams. All of it determined how work actually happened.</p><h4>The Mapped Territory</h4><p>Every team carries history. Failed projects. Legacy systems. Technical decisions made under constraints that no longer exist. Starting with the repair didn’t fix everything at once. It created a foundation for sustainable progress.</p><p>The bugs mattered. But what surfaced during debugging mattered more. The hidden architecture of both the technical system and the human system became visible. The dangerous passages in the temple were marked now. The loose stones were identified. The team knew which paths could bear weight.</p><p>Repair isn’t the opposite of progress. It’s what makes progress sustainable. Feature work can wait one sprint. Understanding cannot.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1bc991ce9a07" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>