<?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 Osher El-Netanany on Medium]]></title>
        <description><![CDATA[Stories by Osher El-Netanany on Medium]]></description>
        <link>https://medium.com/@osherel?source=rss-90db3ed60cfe------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*Q0eC6c8iX5LW1Hag.jpg</url>
            <title>Stories by Osher El-Netanany on Medium</title>
            <link>https://medium.com/@osherel?source=rss-90db3ed60cfe------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 20:18:02 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@osherel/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[A Recovery Cut — Post-Op for Boris Cherny’s Ablation]]></title>
            <link>https://osherel.medium.com/a-recovery-cut-post-op-for-boris-chernys-ablation-43693280f36f?source=rss-90db3ed60cfe------2</link>
            <guid isPermaLink="false">https://medium.com/p/43693280f36f</guid>
            <category><![CDATA[ai-agents-in-action]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[developer-culture]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Osher El-Netanany]]></dc:creator>
            <pubDate>Sat, 05 Sep 2026 18:44:43 GMT</pubDate>
            <atom:updated>2026-09-06T08:17:59.759Z</atom:updated>
            <content:encoded><![CDATA[<h3>A Recovery Cut — Post-Op for Boris Cherny’s Ablation</h3><p>This continues <a href="https://osherel.medium.com/boris-chernys-scalpel-from-cutting-80-of-claude-codes-system-prompt-to-cutting-away-thinking-aac947d84c34"><em>Boris Cherny’s Scalpel</em></a>. You may want to take a peek — you don’t have to. Everything that matters shows up here in brief.</p><p>The cuts were done. The surgery was declared successful. However, it is too early to tell on discharge whether the operation met its goals. You find it later, when recovery turns to be partial. By then, nobody can trace it back to the exact cut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oFXs7hVnS68F-cZGKTN6Vw.png" /><figcaption>Sustain, Preserve …or Recover? (image from <a href="https://mazdaturel.com/20-things-to-expect-after-brain-surgery/">here</a>)</figcaption></figure><p>In his interview, Boris, head of Claude-Code in Anthropic, lists 4 things worth cutting. One can be argued as a smart business move. The other three cut closer to the bone.</p><p>This is the post-operation follow-up visit. <br>Whether the cuts were right isn’t the question anymore.</p><blockquote><em>The question is whether anyone’s watching for what doesn’t come back.</em></blockquote><h3>Doctor’s Orders</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TCUOodoAmZnK49QWjzzHVg.png" /><figcaption>Cut it out. (image from <a href="https://osherel.medium.com/boris-chernys-scalpel-from-cutting-80-of-claude-codes-system-prompt-to-cutting-away-thinking-aac947d84c34">here</a>)</figcaption></figure><p>Boris named 4 cuts:</p><ul><li><strong><em>Cut the harness</em></strong> — since their new models do not need it. Now your harness fits only their models.<br>It’s a witty business move — It creates a gap that closes only once competing models catch up.</li><li><strong><em>Cut the Senior Judgement</em></strong> — delegate it to the model and focus on evaluation. As if nobody needs to step in when an evaluation fails.</li><li><strong><em>Cut the CS instinct</em></strong> that specifies, put your faith that the model will give you what you want. As if it always knows better.</li><li><strong><em>Cut the Theory</em></strong> — experiment for yourselves and see. As if everyone can afford experiments and risks that manifest in costs Boris does not have to face.</li></ul><p>Somewhere in that list, ablation might turn into lobotomy.</p><blockquote><em>The tension is between quality of the code artifact and the quality of the practice that produces it.</em></blockquote><p>The former is the business goal, the latter is how the industry attracts capable coders. Foregoing the quality of coding leaves us with no-one to step in when agents hit the wall like they often do. And with no future generation of capable software engineers.</p><h3>The Writing on the Wall</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hmFl1N5oxiDFU3n7ZWZX0A.png" /><figcaption><em>Not just in comix. (image from </em><a href="https://svensven.net/blog/watchmen/"><em>here</em></a><em>)</em></figcaption></figure><p>Let’s not kid ourselves. We <strong>are</strong> moving away from code. Code — that thing software engineers used to point at and say “I did that”.</p><blockquote><em>50 years ago it was moving from 2nd generation to 3rd generation of programming languages. <br>But I’m reluctant to call prompts 4th or even 5th gen. Sorry.</em></blockquote><p>I got the perfect person for testing this claim. <a href="https://www.youtube.com/@indydevdan">IndyDevDan</a> is a YouTube persona by Dan Eisler. He is <strong><em>not</em></strong> a content-creator. He is a software engineer that does content creation on the side.</p><p>Grew on making Adobe flash games, and worked for Blizzard, landed on finance/accounting software. He did AI coding before it had a name, with tools most people never heard of. Owner of <a href="https://agenticengineer.com/">agenticengineer.com</a>. A very hands-on fella.</p><p>In his words: software factory is SDLC folded into a pipeline an agent can run end to end. This is our futuristic bench that marks things to come.</p><p>His rants run on rigor against vibe. No Anthropic revenue rides on what he says. If he demonstrates a total hands-off — it isn’t a strawman: We <strong>ARE </strong>moving away from code.</p><h3>You Rent Your Models. You Own Your Code.</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/848/1*T8AcqyAUQD-DIot6DjaraA.png" /><figcaption>Not your home. (image from <a href="https://www.wilmingtonbiz.com/real_estate_-_commercial/2022/05/06/office_buildings_finding_new_life/23188">here</a>)</figcaption></figure><blockquote><em>Agents plus Code beats either alone.<br>- </em><a href="https://www.youtube.com/@indydevdan">IndyDevDan</a> / <a href="https://www.youtube.com/watch?v=VQy50fuxI34&amp;t=1869s">Forget about Loop Engineering</a></blockquote><p>By code, he means something specific. Not what agents write — the harness around them: tests, linters, hooks, the pipeline that runs the whole operation. His call is that orchestration and gating are decided by code he wrote, not by an agent’s judgement mid-loop.</p><p>That harness is the system that builds the system (<a href="https://www.youtube.com/watch?v=VQy50fuxI34&amp;t=1331s">source</a>). It is the one thing he states he takes absolute ownership of. He clarifies that while we own our code, we don’t actually own any of our AI models. We’re renting them (<a href="https://www.youtube.com/watch?v=haUfb1ievTE&amp;t=596s">source</a>).</p><p>His approach reverses the ownership model: Even though he pays rent for models — the model becomes a guest in his harness. But his ownership philosophy runs deeper. In his words:</p><blockquote><strong><em>“Vibe coding</em></strong><em> is not knowing how the system works, and not looking at how the system works.<br> </em><strong><em>Agentic Engineering</em></strong><em> is knowing your system works so well you don’t have to look.”<br> - </em><a href="https://www.youtube.com/@indydevdan">IndyDevDan</a> / <a href="https://www.youtube.com/watch?v=VQy50fuxI34&amp;t=1548s">Forget about Loop Engineering</a></blockquote><p>i.e. — He doesn’t look. The gate does.</p><blockquote><em>He looks at the gate.</em></blockquote><p>So that’s Dan.</p><h3>The System That Builds the System</h3><p>One of Dan’s latest works is the Super-Simple-Software-Factory.</p><p>It is a skill — /sssf, packed with a deep toolbox based on <a href="https://pi.dev/">pi</a> - that lets your main agent orchestrate a software factory for you.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mCQG0XtJaKtJxIrztCyu3g.png" /><figcaption><em>Software porn (image from </em><a href="https://youtu.be/haUfb1ievTE?t=1034"><em>here</em></a><em>)</em></figcaption></figure><p>Here, with a wink — “I know everyone’s <a href="https://youtu.be/haUfb1ievTE?t=1027">shocked right now</a>, you can’t bear the sight of looking at code” — he shows the inner works.</p><p>But did he build it from scratch by hand? No. Although he demonstrates a high level of involvement and ownership — he states plainly:</p><blockquote><em>“Yes, I coordinated with agents to build this out.”<br> - </em><a href="https://www.youtube.com/@indydevdan">IndyDevDan</a> / <a href="https://www.youtube.com/watch?v=haUfb1ievTE&amp;t=1032s">My Super Simple Software Factory</a></blockquote><blockquote><em>Ownership survived. Just yet. Authorship didn’t.</em></blockquote><h3>The Same Ladder</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/925/1*fG_p3BM8qBg8ZW68j-PJug.png" /><figcaption>Make it a skill. (image from <a href="https://www.theguardian.com/cities/2019/dec/25/the-christmas-story-of-one-tube-stations-mind-the-gap-voice">here</a> )</figcaption></figure><p>Both Boris and Dan say — invest in your <strong>evals</strong>. <br>They disagree on orchestration — what decides to call evals.</p><p>Boris says sit back, let it cook. He trusts the model to be a good host.</p><p>Dan says — you got to be the landlord. In-loop agent judgement will buckle under context-weight. So you have to wrap the models with your own harness where the evals are baked in as code together with any step that is important to you.</p><p>The difference is a gap of approach. But both are stepping towards a place where you can move at <strong>agentic speed</strong>.</p><blockquote><em>And that is only done by taking the human out of the loop.</em></blockquote><h3>The Challenge</h3><p>Use it or lose it, they say. But then, how does knowledge persist?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MtuZn43PZ170ri5lOOlTVg.png" /><figcaption><em>A severed connection? (image from </em><a href="https://youtu.be/w3d2DlLX7xw?t=295"><em>here</em></a><em>)</em></figcaption></figure><p>Nowadays, there is no way for a doctor to see for themselves what MRI shows. Doctors <strong><em>need</em></strong> MRI.</p><p>There are also some robotic surgeries that no human doctor can perform by holding the knife in their hands. For doctors too, technology solves mainly the <strong><em>how</em></strong>, and it creeps slowly towards the <strong><em>if</em></strong> and the <strong><em>why</em></strong>.</p><p>Nowadays, a software engineer is able to read code without needing a model to explain it.</p><blockquote>The challenge is to keep it this way — while embracing agentic speed.</blockquote><h3>Recovery Protocol</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/769/1*jT2LtFrauXyJKeGTy0OWTw.png" /><figcaption>Breath in (image from <a href="https://ca.healthcare.airliquide.com/medical-applications/hypoxia">here</a>)</figcaption></figure><p>The star of this section is <strong>Kent Beck</strong>. I would like to think <a href="https://www.google.com/search?q=kent+beck">he needs no introduction</a>.</p><p>Kent is the closest thing we got to a Sage of SDLC.</p><p>Kent shares with us an inspiring perspective. One that should lead us to curing habits. Such that will keep the practice and knowledge alive.</p><h3>Enter — The Genie</h3><p>For decades, software development was pretty much the same. Some variables, ifs, loops. We hoped we figured how to preserve domain knowledge and keep code clean. But while we were moving at what we thought was a break-neck speed — there comes a Genie.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vP-Q-2xL2PHo8rXqMQQfxw.png" /><figcaption><em>Mind what you ask. (image from </em><a href="https://www.vanityfair.com/hollywood/2019/04/aladdin-genie-footage-cinemacon"><em>here</em></a><em>)</em></figcaption></figure><p>A Genie that grants wishes on command.</p><blockquote>But never what you meant. Only what you said.</blockquote><p>Usually with decontextualized interpretations, and often with some of his own embellishments.</p><h3>The 3X Model</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1iYO92idQ70zJfiCZ9f9FA.png" /><figcaption><em>What are the stakes? (image from </em><a href="https://youtu.be/sMujMp4h_EY?t=1067"><em>here</em></a><em>)</em></figcaption></figure><p>Kent distinguishes between 3 main stages in the life of software, which he calls the 3X model.</p><ul><li><strong>Exploration</strong> — where mistakes are cheap, options are open, and creativity wins goals. It doesn’t look very much like engineering from the books. It’s about cutting corners to get answers. The risks are low.</li><li><strong>Expansion</strong> — where stakes are climbing, options are closing down. A creative thing you explored takes off, and now you’re dealing with growth challenges. How to scale up service? How to scale up development? The risk here is to lose an opportunity.</li><li><strong>Extraction</strong> — where stakes are high, options are limited by commitments, and mistakes cost dearly. Every creative idea here is measured first against risk. The risk here is to lose what you’ve got.</li></ul><p>These are different modes of work, not roles. Each mode requires different conduct and has a different payoffs: In its current form, the Genie is great at exploration. But is actively dangerous in Expansion/Extraction.</p><p>Already before the Genie we felt the tension between features and technical debt. A balance that came with experience. Codebases of businesses that capitalized on technical debt without paying it back came crashing down. They reached a point where they are no longer maintainable.</p><p>Pre Genie codebases typically did that in years, which is eternity in terms of software. Good practices kept tech-debt at bay, delaying old age. Now with the Genie unchecked, it comes in months.</p><blockquote>Suddenly, a break-neck speed got a whole new meaning.</blockquote><h3>Back to the Unknown</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*gVeLus21qSZVH0PnDnarIA.png" /><figcaption>Abstract thinking (image from <a href="https://thevirtualinstructor.com/blog/understanding-abstract-art">here</a>)</figcaption></figure><p>Now, here’s a meta thought.</p><p>For 45 years software development itself has lived in extraction. And while we made ourselves comfortable, there comes the Genie,</p><blockquote><em>and sends programming itself back to exploration.</em></blockquote><p>Now, how do you protect a high-stake product in extraction stage with programming form that is in itself being explored? How do you guarantee that your domain knowledge stays and that your options are open?</p><p>I daresay — definitely not by cutting CS, Boris — but by celebrating it.</p><h3>Optionality</h3><p>This POV establishes possibilities — Open <strong><em>Options</em></strong> — as the main <strong><em>Currency</em></strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Wo1zYmLuMzTSbqV2d0r7-Q.png" /><figcaption><em>Keeping lights up (image from </em><a href="https://youtu.be/sMujMp4h_EY?t=2159"><em>here</em></a><em>)</em></figcaption></figure><p>The x-axis in this graph is not time, but features.</p><p>You start high on the top-left, where options are unlimited, but no feature is delivered yet. Delivering features fast usually means trading options for features and capitalizing on technical debt. Until you come to a point where no free options left. Every delivery requires a lot of prior work. Work to rearrange things to create options for new features.</p><p>Kent calls the line on the bottom right <strong>the features-saw</strong>, and a terrible place to sit in. Mind again that since x is not time — a small climb to open some options can take a long time. This is where unchecked tech-debt has caught up with you.</p><p>But by now you’re no longer in exploration — mistakes aren’t cheap. You’re most likely in expansion.</p><blockquote>Your risk is to miss the race.</blockquote><h3>Growing Options</h3><p>Kent calls the solution <strong>Investing in Optionality</strong>.<br> The alternative trajectory looks like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MiprQMdWUzo0GGnLZDPI6w.png" /><figcaption><em>Opening options (image from </em><a href="https://youtu.be/sMujMp4h_EY?t=2286"><em>here</em></a><em>)</em></figcaption></figure><p>I cannot pretend to be able to explain it here. I can point you the way for your own exploration.</p><p><a href="https://osherel.medium.com/do-coding-agents-make-architecture-irrelevant-2de1eca45f2b">Architecture</a> is not about the code that exists today. It is a premium insuring the cost of the code that doesn’t exist yet. But the later you enter an insurance program — the more expensive it is, to the point that later becomes never. That’s why <a href="https://www.oreilly.com/library/view/tidy-first/9781098151232/">Tidy First</a>.</p><p>How do we do that with agents? A proven checklist you can follow is yet to emerge. Programming went all back to <strong><em>exploration</em></strong>, mind you. But we still have the generation that had seen it all a couple of times before and knows to reach for a higher view to at least orient to the general right direction.</p><ul><li><a href="https://osherel.medium.com/do-coding-agents-make-architecture-irrelevant-2de1eca45f2b">Architecture</a> is a private case of optionality.</li><li><a href="https://medium.com/israeli-tech-radar/do-you-waterproof-your-software-e9ba250bd8bd">Automation</a> —e.g. like using better harness and evals in CI is one more.</li><li><a href="https://medium.com/israeli-tech-radar/keeping-relevance-in-a-world-of-constant-change-7ec074ff8236">Personal skills</a> is another.</li><li>And so is <a href="https://medium.com/israeli-tech-radar/whats-your-professional-experience-e72c61bd18b3">culture</a>, (which I like to think of as a skill of a group).</li></ul><p>All of these are established by experience. But what is being pointed out here is:</p><blockquote><em>The Generational Chain itself.</em></blockquote><h3>The Chain</h3><p>Our industry roughly <a href="https://www.youtube.com/watch?v=ecIWPzGEbFc&amp;t=3087s">doubles in size every 5 years</a>. At any point in time, half of the programmers have less than 5 years experience.</p><p>We are in a state of <strong><em>perpetual </em></strong>inexperience.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0rgUSLCVQCebi9Z3HbefgA.png" /><figcaption>The weakest link (image from <a href="https://gameofthrones.fandom.com/wiki/Order_of_Maesters">here</a>)</figcaption></figure><p>I subscribe to the view that the Genie will accelerate that. As software becomes cheaper — it will become viable for things for which we do not afford to do with software.</p><blockquote>The need for developers will stay, although it is no longer the same job.</blockquote><h3>The next Link on the Chain</h3><p>According to Kent — nowadays, hiring juniors has the potential to make financial sense more than ever.</p><p>The Genie is great at exploration. And guess what. Learning is exploration: It is a great tutor. It has access to knowledge even when it does not have the wit to leverage it to its full potential. And it has an unrelenting patience to reiterate and explain things over and over.</p><blockquote><em>I myself caught up with SOC and SOC2. Not the nit-picking requirements that I have already met before, but the philosophy, the design, the approach.<br> Agents turned long siege-campaigns against intimidating walls-of-text into a welcoming guided tour.</em></blockquote><p>Pair a Genie with a junior and require them to explore together. The Genie could curb their learning curve upwards (from red to the blue below), making them profitable sooner.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zNRnujl4N6dSErJPz-asLg.png" /><figcaption><em>Up up up. (image from </em><a href="https://youtu.be/sMujMp4h_EY?t=2831"><em>here</em></a><em>)</em></figcaption></figure><p>The fine print is that like in coding, Genie’s mistakes have to be pruned out actively also in tutoring. Exploring unchecked — there’s no knowing where you might be swept off to.</p><blockquote>This calls for culture of mentorship, roadmap and knowledge sharing.</blockquote><p>Preserving knowledge means get the next generation up to the top of the knowledge ladder and funnel their creativity to the next layer of innovation.<br> …Instead of solving the same problems all over again.</p><p>Problems in algorithm. Problems in structure. Problems in practice. And in culture.</p><p>It requires a change of perception.</p><h3>A better Look</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LMEtnNfJUifu2n4OWPwTYQ.png" /><figcaption>The right focus (image from <a href="https://www.happiness.com/magazine/inspiration-spirituality/perspective/">here</a>)</figcaption></figure><p>The guardrails appear when you change perspective.</p><p>Treat the journey as a learning experience. One that chases <strong>knowledge </strong>and produces exemplary products. That, instead of a chase for products that yields knowledge as disposable byproduct.</p><p>Nothing has changed on the business level — you still have goals and deadlines. But the perspective through which you look isn’t solely <strong><em>what we produced</em></strong>. It moves towards the very thing that will make the next generation of software and people alike:</p><blockquote><em>What did we learn while producing it that will make the next production better?</em></blockquote><h3>Discharge Instructions</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_7q9i8VnvtQFg3I5nehyhg.png" /><figcaption>Recover, Preserve, Evolve. (image from <a href="https://mazdaturel.com/20-things-to-expect-after-brain-surgery/">here</a>)</figcaption></figure><p>Nowadays, a software engineer is able to read and write code without needing an agent, just yet.</p><p>Will it stay this way? Nobody knows.</p><p>Should it?</p><p>The next generation is going to program in ways that will completely baffle the old.<br>For our own sake, we need to put them on the shoulders of giants. Bringing them there will hone their skills, and preserve ours.</p><blockquote>Do it by establishing practices of mentorship, roadmap and knowledge sharing.</blockquote><p>The physiotherapy of the post AI brain surgery, if you like.</p><p>How does it look? Let me know in comments if you would like a sequel zooming in on that.</p><p>The fight is real, the mechanism is sound, the adoption is not guaranteed. However, there is some hope cut out for us.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/698/1*29J0hDki_OFzXdIGoD8RFg.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=43693280f36f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Boris Cherny’s Scalpel - from cutting 80% of claude code's system prompt to cutting Computer…]]></title>
            <link>https://osherel.medium.com/boris-chernys-scalpel-from-cutting-80-of-claude-codes-system-prompt-to-cutting-away-thinking-aac947d84c34?source=rss-90db3ed60cfe------2</link>
            <guid isPermaLink="false">https://medium.com/p/aac947d84c34</guid>
            <category><![CDATA[developer-culture]]></category>
            <category><![CDATA[ai-agents-in-action]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Osher El-Netanany]]></dc:creator>
            <pubDate>Mon, 10 Aug 2026 12:50:30 GMT</pubDate>
            <atom:updated>2026-09-10T13:26:24.079Z</atom:updated>
            <content:encoded><![CDATA[<h3>Boris Cherny’s Scalpel</h3><p>Boris Cherny got cheers for something that should, on its face, terrify him.</p><p>He had deleted 80% of Claude Code’s system prompt. He sat on stage, days after Opus 5. The room approved.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oL-L549CO1dwfaZWZdgEYw.png" /><figcaption>Opus 5. A sharp model. (image from <a href="https://youtu.be/qyPCVqFUyDo?t=79">here</a>)</figcaption></figure><p>Here’s the thing. Opus 5 ran unattended for weeks.</p><ul><li>One prompt rewrote Bun’s entire runtime, over 100K lines, Zig to Rust. In eleven days.</li><li>Another prompt was still running two weeks later, rebuilding in swift a desktop app. All while live-blogging its own progress in Slack.</li></ul><p>If you’ve tasted in the last year fighting a model into doing what you <em>actually </em>meant, watching this interview feels like watching someone finally get away with something.</p><h3>Boris’s Message, Simply put</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TCUOodoAmZnK49QWjzzHVg.png" /><figcaption>Doctor’s orders. (image from <a href="https://youtu.be/qyPCVqFUyDo?t=744">here</a>, with <a href="https://share.gemini.google/bsVkarxeCHPf">some help</a>)</figcaption></figure><p>Cherny has a word for the practice: <strong>Ablation</strong>.</p><blockquote>Note: I have nothing but respect for Boris, and we’ll get back to it later.</blockquote><p>He means it as a compliment to the method. Cut tissues that aren’t load-bearing, keep what survives.</p><blockquote>It’s a good word. It’s a more honest word than he thinks.</blockquote><p>Here’s my summary of the message, as he gave it, with direct links to the points in the interview where he says each point:</p><ul><li><strong>Cut the harness.</strong> Boris’s team <a href="https://www.youtube.com/watch?v=qyPCVqFUyDo&amp;t=270">deleted 80% of Claude Code’s system prompt</a>. He dared the room to cut the rest.</li><li><strong>Cut the CS instinct.</strong> <a href="https://www.youtube.com/watch?v=qyPCVqFUyDo&amp;t=1456">Stop specifying, structuring, pre-deciding</a> how the model should work. He calls that a <strong>failure mode</strong>, not a virtue.</li><li><strong>Cut the judgement</strong>. Delegate to the model. <a href="https://www.youtube.com/watch?v=qyPCVqFUyDo&amp;t=892">Describe the goal, the guardrails, the exit criteria</a>. Step back, he sais. Let it cook.</li><li><strong>Cut the theory</strong>. Experiment: Delete, observe empirically. <a href="https://www.youtube.com/watch?v=qyPCVqFUyDo&amp;t=363">Bring back only what its removal breaks</a>. For every release.</li></ul><h3>The Procedure Protocol</h3><p><a href="https://www.youtube.com/watch?v=qyPCVqFUyDo&amp;t=361">Ablation</a> is a real word from the <a href="https://www.cancer.gov/publications/dictionaries/cancer-terms/def/ablation">world of surgery</a>. Restore function by cutting tissues that aren’t serving the system, guided by diagnostics.</p><p>A real ablation protocol includes three things Boris’s version skips.</p><ol><li>Pre-op diagnostics — is this organ actually fit for the cut, right now.</li><li>A success criterion — wider than “the patient survived.”</li><li>Post-op monitoring — not the same check repeated. Its watching for the kind of harm that doesn’t show up at discharge and only surfaces months later.</li></ol><p>The procedure protocol is what makes sure that when you try an ablation you don’t end up with a <a href="https://www.youtube.com/watch?v=w3d2DlLX7xw">lobotomy</a> 😳.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MtuZn43PZ170ri5lOOlTVg.png" /><figcaption>A severed connection. (image from <a href="https://youtu.be/w3d2DlLX7xw?t=295">here</a>)</figcaption></figure><h3>A matter of Quality</h3><p><a href="https://www.penguin.co.uk/books/360611/zen-and-the-art-of-motorcycle-maintenance-by-pirsig-robert/9780099786405">Robert Pirsig</a>, the American author and philosopher, named it over 50 years before Boris did. He called it <strong>the scalpel of the classical mind</strong>. His character, Phaedrus, was <strong><em>the</em></strong> master at using it. <br>Take an undivided experience and cut it into named, analyzable parts. A motorcycle stops being a ride and becomes a carburetor, a spark gap, a torque spec, etc. Each designed to solve a smaller better defined challenge in the grand scheme of things.</p><p>What Pirsig warns against is where you point it. Pirsig calls that tacit sense a mechanic has for the machine — Quality. Coders will recognize it as the quality of coding. Point the knife at Quality itself — the moment the itemizing is done, Quality has already left the room. You can <a href="https://osherel.medium.com/talk-to-my-agent-24d771611910">codify a practice</a> into the harness. You may reduce bugs, but you won’t capture <strong><em>that </em></strong>Quality.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/959/1*uOzgGZWYix7EJCzHvLjI0w.png" /><figcaption><em>Dismantled system prompt. Or a developer’s mind. (image from </em><a href="http://www.rcycle.com/1970HondaCB750KOengine.html"><em>here</em></a><em>)</em></figcaption></figure><p>It’s the same knife Boris is holding. Cut an AI harness down to its load-bearing parts, or cut a motorcycle down to its named components — same move. The difference is what’s left on the table once the knife has come down.</p><h3>Boris’s Scalpel, Phaedrus’s Scalpel</h3><p>Boris’s ablation, scoped to the harness — prompt, tools, hooks, cut to find what a <em>model</em> actually needs — is the seemingly harmless. But the same gesture, sold as a way of working, doesn’t stop at the harness. It asks the <em>developer</em> to cut their own instinct of making sure the engine is accessible and maintainable. Here the knife is turned on a person’s experience instead of a machine’s config.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HRQvScF98o1tc1nkM4GqhA.png" /><figcaption><em>Pointing at the door (image from </em><a href="https://www.anthropic.com/research/AI-assistance-coding-skills"><em>here</em></a><em>)</em></figcaption></figure><p>This isn’t a metaphor. In January, Anthropic’s own research team <a href="https://www.anthropic.com/research/AI-assistance-coding-skills">ran the test</a>. They picked 52 engineers, half coded by hand, half with an AI assistant that could see their workspace and generate solutions on demand. Then, quizzed them on what they did minutes earlier. The AI group scored <strong>17% lower</strong> . And the widest gap wasn’t output. It was debugging: the ability to tell code is wrong, and say why. That’s Quality, measured, and found leaving.</p><ul><li>The high scorers didn’t avoid the agent. They used it to ask, to explain, to build comprehension alongside the output.</li><li>The low scorers delegated to the agent, then debugged by asking the agent to debug.</li></ul><p>Read Boris’s cuts against that, and notice which side they land on. <br>(And guess who unequivocally needs more tokens…)</p><h3>Signs of Vitality</h3><p>I can understand the plea — cut everything out and just try the model. That’s easy for him to say. Especially with reservation for <a href="https://www.youtube.com/watch?v=qyPCVqFUyDo&amp;t=1840s">the type of coding he does</a>. As if claude-code has no depth, or is not a part of distributed computing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/824/1*CdXMNUXwwYv9MtKlkIpE5Q.png" /><figcaption>The flat line is also the simpler (<a href="https://share.gemini.google/DJzbNXbevc9m">generated</a>)</figcaption></figure><p>His success criterion is about evals. <a href="https://www.anthropic.com/engineering/demystifying-evals-for-ai-agents">Anthropic’s definition</a> of an eval is well defined: the result the model provided against a given input, scored against a success measure by grading logic. Some run as code, some run as other LLMs. And they all reduce to a quantifiable score benched against a bar.</p><p>But that’s correctness. Did the tests pass? Did the lint pass? Did it pass a security scan? Does the model rank the code usable? It says nothing about whether flexibility, judgement, and ownership survived the cut.</p><h3>The Ivory Tower</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/973/1*7GiDfGPkRtDPqrhXPw5hfw.png" /><figcaption>A never ending story (image from <a href="https://youtu.be/jHcMAlYFn8Y?t=38">here</a>)</figcaption></figure><p>The average developer cannot afford what Boris does not have to pay for. There are a few things his advice assumes are free.</p><ul><li>It assumes you always reach for the latest and strongest model, no cost consideration attached.</li><li>It assumes you can <a href="https://www.youtube.com/watch?v=qyPCVqFUyDo&amp;t=1796">run as many agents in parallel as you need</a>. His own team does exactly that, “hundreds of agents running every day, sometimes thousands,” on the house.</li><li>And it assumes you can afford to run the experiment for the sake of experimentation: cut one system-prompt element, hold everything else constant, <a href="https://www.youtube.com/watch?v=qyPCVqFUyDo&amp;t=570">measure, then cut the next one</a>.<br>There’s also an implied assumption that all losses are measurable in experimentaiton time.</li></ul><p>Boris operates with a full surgical team, air conditioning, lights, and a monitor on every vitality sign.</p><blockquote><em>Most developers get a field-paramedic bag and hope the patient can hold the torch.</em></blockquote><h3>The Last Model Standing</h3><p>Boris recommends optimizing your local setup to the cutting-edge model. As if people are using one model exclusively. Every beat assumes a take over — <a href="https://www.youtube.com/watch?v=qyPCVqFUyDo&amp;t=330">delete the prompt and start from scratch, every time a new model ships</a>.</p><p>So, in addition to the production code and to the setup that runs the production code (e.g. IaC &amp; CI/CD code), software professionals are now required to own one more thing: their harness setup. It was OK as long as it was an accumulated knowledge that grows and makes you harness powerful. Now Boris states it’s a burden that <a href="https://www.youtube.com/watch?v=qyPCVqFUyDo&amp;t=716">stands in the way</a> of the modern models.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-I0eU3stGgSsN8GbkK9U6g.png" /><figcaption>Don’t mix the tanks. (<a href="https://app.leonardo.ai/generation/image/row-labeled-terrariums-shelf-each-holding-ba8ad6b2-0627-4e83-bfd9-9fac47758b97">generated</a>)</figcaption></figure><p>But serious agentic users already run a cost-effective model stack:</p><ul><li>a cheap, fast model for the grunt work,</li><li>a workhorse model for the everyday job,</li><li>a frontier model for the hard reasoning.</li></ul><p>The moment there is more than one model, the practice needs a per-model isolated harness with its own prompt and skills. I.e. — a proper sandboxing, not a ~/.claude/ folder repopulated every quarter.</p><p>Delete-and-rebuild is a release note. Three models on payroll is a fleet. And now the fleet needs a bigger infrastructure. That, or use just one model.</p><blockquote>The more expensive one, obviously.</blockquote><h3>Use It. And Lose It</h3><p>People think brains stop evolving at a certain age. They are wrong. Neurological pathways are expansive: Your brain runs an evolutionary race between its neurological pathways every time you sleep. What is used gets reinforced, what is stale gets pruned. You don’t need a scalpel to do that.</p><p>But, biologically speaking, the factor that determines what gets used is not quality of performance or efficiency. It’s the reward system.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*DmZTufFwDjaF9go_XHypWg.png" /><figcaption><em>Organic pruning in action (image from </em><a href="https://www.lifeextension.com/wellness/sleep-relaxation/10-benefits-of-getting-enough-sleep?srsltid=AfmBOoqLTQ5MyXn5UGv3I-y-IDtGzS_y9uGarKxhTATA_3JjAlqMa6xJ"><em>here</em></a><em>)</em></figcaption></figure><p>Now, let’s get a closer look at quality of code and quality of coding:</p><ul><li>Quality of <strong><em>code</em></strong> is the intrinsic value of the code artifact, once it’s produced. No matter how you produced it. It is the one associated with business value — The <a href="https://learn.genetics.utah.edu/content/metabolism/atp/">ATP</a> of the business.</li><li>Quality of <strong><em>coding</em></strong> is what developers signed for when they decided to engage the industry. It is that load-bearing reward system —for developers, its the …<a href="https://theconversation.com/why-do-people-and-animals-need-to-breathe-a-biologist-explains-why-you-need-a-constant-source-of-oxygen-219169">Oxygen</a>.</li></ul><p>You can keep shipping code quality for a while after the coding quality has left the room. Just like final death comes a good while after the heart stops.</p><p>The tension is that Boris suggests that <a href="https://www.youtube.com/watch?v=qyPCVqFUyDo&amp;t=1907">computer science can be cut out</a> and describes the part that guards the oxygen as a <a href="https://www.youtube.com/watch?v=qyPCVqFUyDo&amp;t=1453">failure mode</a>.</p><p>Sacrifice the quality of coding for the quality of code and you’re not skipping a step. You’re withholding the reward system that keeps these brain pathways functional.</p><blockquote><em>Here, the knife cuts away much more than the removed material.</em></blockquote><h3>The Envoy</h3><p>He isn’t a random engineer swapping war stories at a meetup. He’s the <a href="https://www.linkedin.com/in/bcherny/">head of Claude Code</a>, on Anthropic’s stage, days after Anthropic shipped <strong>Opus 5</strong>.</p><p>Mind that this changes the incentive under the words, not the words themselves.</p><p>What’s sold as <strong><em>empirical</em></strong> — humble, scientific, just running the trial and watching results — is an appeal for more power. In other words — <strong><em>imperial</em></strong>.<br> Deferring judgement to the Empire’s model, on the Empire’s terms, funded by the Empire’s incentive to keep you deferring.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/650/1*qhTXnDLFJF0mcXp9Ak6uwA.png" /><figcaption><em>The root of the Slavic name Boris Cherny means </em><a href="https://www.google.com/search?q=boris+cherny+meaning+of+the+name&amp;sca_esv=fd25005b0ac42467&amp;sxsrf=APpeQnvbizXSVDK422QrcLSttmIP_5hZHA%3A1786018294805&amp;ei=9nl0arTaMPWPi-gP47bggQg&amp;biw=1858&amp;bih=993&amp;ved=0ahUKEwi0rZjQ_IuWAxX1xwIHHWMbOIAQ4dUDCBA&amp;uact=5&amp;oq=boris+cherny+meaning+of+the+name&amp;gs_lp=Egxnd3Mtd2l6LXNlcnAaAhgCIiBib3JpcyBjaGVybnkgbWVhbmluZyBvZiB0aGUgbmFtZTIIECEYoAEYwwRIwIMBUPkLWPqAAXAGeAGQAQCYAZICoAHPMqoBBzAuMTkuMTa4AQPIAQD4AQGYAimgApI0wgIKEAAYRxjWBBiwA8ICDhAAGOQCGNYEGLAD2AEBwgIXEC4Y3AYYuAYY2gYY2AIYyAMYsAPYAQHCAgsQLhiABBiKBRiRAsICCxAAGIAEGIoFGJECwgIIEAAYgAQYsQPCAgsQABiABBixAxiDAcICDhAAGIAEGIoFGLEDGIMBwgIREC4YgAQYigUYsQMYxwEY0QPCAgsQABiABBiKBRixA8ICFBAuGIAEGIoFGLEDGIMBGMcBGNEDwgIaEC4YgAQYigUYkQIYlwUY3AQY3gQY4ATYAQHCAgoQIxjwBRjJAhgnwgILEC4YgAQYsQMYgwHCAhEQLhiABBixAxiDARjHARjRA8ICChAAGIAEGIoFGEPCAggQLhiABBixA8ICBRAuGIAEwgIREC4YgAQYiwMYogUYqAMYnQPCAg4QLhiABBiLAxiaAxioA8ICFBAuGIAEGLEDGIMBGIsDGKgDGJoDwgIUEC4YgAQYsQMYgwEYiwMYqAMYpAPCAhQQLhiABBjHARjRAxiLAxioAxjSA8ICChAuGIAEGIoFGEPCAgQQABgDwgIZEC4YgAQYigUYQxiXBRjcBBjeBBjfBNgBAcICBRAAGIAEwgIUEC4YgAQYlwUY3AQY3gQY3wTYAQHCAgUQABjvBcICCBAAGIAEGKIEwgIFECEYoAHCAgkQLhiABBgKGAvCAgkQABiABBgKGAvCAhgQLhiABBgKGAsYlwUY3AQY3gQY3wTYAQHCAgsQABiABBiKBRiGA8ICBhAAGBYYHsICBBAhGBXCAgcQIRgKGKABmAMAiAYBkAYPugYGCAEQARgJkgcHNi4xOC4xN6AHmvACsgcHMC4xOC4xN7gH4jPCBwk1LjE5LjE1LjLIB4UBgAgB&amp;sclient=gws-wiz-serp"><em>dark warrior</em></a><em>. (image from </em><a href="https://www.cinemablend.com/news/2487414/star-wars-palpatine-actor-was-just-as-surprised-as-fans-about-his-return"><em>here</em></a><em>)</em></figcaption></figure><blockquote>Apply the scrutiny you’d give any pitch from the party who profits if you say yes.</blockquote><p>The direct outcome of such advice is more dependency on ever-larger frontier models.</p><p>Now, I got nothing but respect for Boris. His contribution is immeasurable. But this message deserves a reality check. It comes from bigger forces.</p><p>The irony of hearing that from the father of the Claude Code harness should not escape notice — the weight shifting from harness to model. Its undermining Claude Code itself. Anyone running an Anthropic heavyweight model through their own agent on API key feels the same pull.</p><p>We are expecting a wave of new models that will render all previous models and lessons learned about them obsolete. Apropos cutting edge…</p><h3>A save point</h3><p>When I set out to write this article I had two more important angles to visit. To shove them here in the remaining word budget is to do them injustice. I’ll have to do that in <em>A Recovery Cut</em> — the currently proposed name for the sequel to this post.</p><p>But I wont leave you hung on air either. Here’s the preview.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/690/1*44NG8RfH0u6sQPrMcjGZ1w.png" /><figcaption>Can we still reach that wheel? (image from <a href="https://pixabay.com/photos/hierro-sea-rescue-waves-lifebuoy-2055549/">here</a>)</figcaption></figure><p>Let’s not kid ourselves — <a href="https://www.youtube.com/watch?v=haUfb1ievTE">the writing is on the wall</a>. We are not going to code by ourselves just like we do not write assembly as a first choice. It took the industry <a href="https://www.google.com/search?q=how+long+did+it+take+the+industry+to+stop+using+assembly+and+using+mainly+compiled+languages">literally decades</a> to abandon assembler for higher level languages, but it eventually happened.</p><p>Autonomous cars do not have to be perfect, they have to be better than us. And they were <a href="https://youtu.be/7Pq-S557XQU?list=PLfY7UD_S2MOJAbbu5Phz55wuU4f__rAkV&amp;t=298">already 12 years ago</a>. The barrier is not technological. It is control and trust.</p><p>I don’t know how I would like a world where the only thing you can do to evaluate code by a model is to pit the poor stateless bastard against itself or if you can, against another model.</p><p>But then again, the only way to know the worth of an accountant or a lawyer is to pit them against another. What’s the difference?</p><p>We live in a world of CT, MRI and molecular DNA tests. Not all of them are fully deterministic and all involve sophisticated software and require a significant amount of computation. So much so that we are required to queue for access to them, not to mention the bill.</p><p>The doctor cannot see what MRI shows without MRI. However, a developer — can appreciate software architecture and understand code. Just yet.</p><p>These are worth saving. And there is some hope cut out for us.</p><p><strong>UPDATED: 2026-Sept-6th:<br></strong>The promised sequel is here:<strong> </strong><a href="https://https//osherel.medium.com/a-recovery-cut-post-op-for-boris-chernys-ablation-43693280f36f">a-recovery-cut — a-post-op-for-boris-chernys-ablation</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/698/1*29J0hDki_OFzXdIGoD8RFg.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aac947d84c34" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Talk to my Agent]]></title>
            <link>https://osherel.medium.com/talk-to-my-agent-24d771611910?source=rss-90db3ed60cfe------2</link>
            <guid isPermaLink="false">https://medium.com/p/24d771611910</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[future-of-work]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <dc:creator><![CDATA[Osher El-Netanany]]></dc:creator>
            <pubDate>Tue, 28 Jul 2026 12:21:18 GMT</pubDate>
            <atom:updated>2026-09-16T08:26:27.609Z</atom:updated>
            <content:encoded><![CDATA[<p>Here follows some cited AI-driven layoffs, Q1+2 2026.</p><p>Meta: <a href="https://finance.yahoo.com/sectors/technology/articles/meta-layoffs-2026-8-000-114209703.html">8,000 employees</a>. Microsoft: <a href="https://www.nbcnews.com/business/consumer/microsoft-layoffs-xbox-gaming-rcna353019">4,800 employees</a>. Oracle: <a href="https://www.forbes.com/sites/maryroeloffs/2026/06/23/ai-cost-21000-jobs-at-oracle-this-year-and-more-layoffs-could-be-coming/">21,000 employees</a>. Cloudflare: <a href="https://fortune.com/2026/05/21/cloudflare-ceo-matthew-prince-layoffs-ai-automation-measurers/">1,100 employees</a>. Snap: <a href="https://www.fastcompany.com/91527233/snap-snapchat-layoffs-today-job-cuts-as-ceo-evan-spiegel-touts-ai-advances">1,000 employees</a>. Monday.com: <a href="https://www.haaretz.com/israel-news/tech-news/2026-07-22/ty-article/.premium/israeli-tech-firm-monday-com-to-lay-off-fifth-of-workers-as-shares-dip-by-50/0000019f-8934-d460-abff-cf7cb8f90000">620 employees</a> — a fifth of its workforce.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Nnh7ekhqjp5ZQxaTL-I1zg.png" /><figcaption>Undeniable. Even if part of it is AI-washing (montage of screen captures using <a href="https://pixlr.com/photo-collage/">pixlr</a>)</figcaption></figure><p>That’s just random top few. Maybe your company already gave a press release about their layoffs. Or maybe it’s one update away.</p><p>Over 168,000 across 467 events, if to believe — <a href="https://techjournal.org/tech-layoffs-2026-ai-spending">techjournal.org</a>.</p><p>The raised question is:</p><blockquote>Where are we going with this? Is my place secure?</blockquote><h3>TL;DR</h3><p>Coding agents aren’t the story — codifying is. This is CI/CD’s last mile. Finally reaching the one stage automation never touched: the writing of the code itself. Same pattern every automation wave has run before: the trade dies, the industry grows, just not evenly. <br>Out of a 100% coders very few will end up owning the standard; the rest will move to software adjacent jobs. Between here and there sits a valley nobody’s hiring plan accounts for. Whichever side you land on — the real question was never the job title, it’s whether you own the agent, or it owns you.</p><h3>The Right time (or, no more Left left)</h3><p>This isn’t software’s first turn of the ratchet. Ask anyone who used to run manual regression suites for a living.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9rWF9VxJ4yGiMt3BC7a3fw.png" /><figcaption><em>Too strong financial incentives push it only one way. (image from </em><a href="https://youtu.be/hzEXq_Rtci8?t=15"><em>here</em></a><em>)</em></figcaption></figure><ul><li>QA got automated first.</li><li>Ops merged into dev and picked up a new name — DevOps.</li><li>Platform engineering absorbed both. And turned infrastructure itself into another thing you build, test, and ship.</li></ul><p>It took the better part of fifteen years, one pipeline at a time.</p><h3>The Buffer Zone</h3><p>All that time, developers stayed busy. Every hour freed up on their schedule got refilled from the left, never from the right.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/995/1*ew8_Lsn2AneqKq6knHFJYQ.png" /><figcaption>Did you get the memo? (img from <a href="https://youtu.be/jsLUidiYm0w?t=44">here</a>)</figcaption></figure><p>Why? Because we kept them away from customers and stakeholders — buffered by PMs. Product managers, program managers, process managers, etc.</p><p>There’s so much to do: code, test, review, deploy, document, debug, close tech-debt. Who has time for stakeholders and their market-trend tantrums? Besides. We like our developers technically proficient. Highly technical. We admire the dev-jargon. “Putting them in front of a stakeholder is a bad idea.” 🙉🙈 😰</p><blockquote><em>But when there’s no more to absorb from the Left, it is the Right time.</em></blockquote><h3>CI/CD’s Last Mile</h3><p>So. The trend CI/CD’s started years ago has finally reached the end. The last stage it never touched — the writing of the code itself.</p><p>Why now? Perhaps because attention finally turned to the reliability of the gate itself. Once the gate holds, the implementation stops mattering. It can always be regenerated to meet it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V34jsuxHbXaosFf3jRP0ag.png" /><figcaption>Our current gating in ripeness is like the first Selenium suites compare to modern playwright.</figcaption></figure><p>Shift-left finally reaches its last stage. And before that? Examples aplenty. Ever heard of Luddites?</p><h3>From Coding to Codifying</h3><p>Here’s the pun:</p><p>Code can be read as a verb: write one instruction at a time, telling the machine what to do.</p><p>It also is a synonim noun to a Cypher.</p><p>But also Codex, a body of rules something else must answer to. Moral code. Legal code. Building code. You dont negotiates with a building code mid-construction…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/665/1*lVOF1xKml5whdkl2N0BCXA.png" /><figcaption>People died over it. (image from <a href="https://www.facebook.com/groups/799987083411428/posts/7909941029082629/">here</a>)</figcaption></figure><ul><li>Coding is giving instruction.</li><li>Codifying is setting a standard.</li></ul><blockquote>To codify a rule is not to state it.</blockquote><blockquote>It’s to make it Non-Negotiable.</blockquote><p>And no, telling an LLM its instructions are non-negotiable does not make them so. That’s the single most significant mistake in the premise of prompt-engineering.</p><h3>Defensible Gate</h3><p>A rule in a prompt is Advisory. You may state it in caps, repeat it three times, thread it through every system message. The model still weighs it against everything else competing for its attention. And under enough pressure, deprioritizes it. That’s not a bug. That’s what advisory means.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/716/1*qGlhteob6Gs0tfGkVJRBLQ.png" /><figcaption>knock knock… (image from <a href="https://www.medievalchronicles.com/medieval-castles/medieval-castle-parts/castle-gatehouse/">here</a>)</figcaption></figure><p>A mechanism doesn’t ask. It wraps the agent’s output and blocks the path forward until the standard is met, full stop.</p><p>The gate itself runs deterministic code (e.g lint). Or another agent as a judge. The gate’s reliability is a separate question from whether it ran or not. If you cannot run past it — it’s a gate. If you can — its a backdoor.</p><p>Any backend developer already knows this. You don’t trust a client with your API contract. You validate its output server-side, every time. <br>Treat the agent the same. AI agent may have run your tests, it may have not.</p><blockquote>Codify is to build the wall an agent can’t argue past.</blockquote><h3>No More Luddites</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H3lYqhpRSPESqsZRub3O7w.png" /><figcaption>This one is still manual, works on weights. (image from <a href="https://seaviewweavers.files.wordpress.com/2011/03/weaving1.jpg">here</a>)</figcaption></figure><p>Before the word became a meme for anyone who resists a new gadget, it named an actual trade: Hand-loom weavers. And the mechanized looms that made their skill redundant within a single generation.</p><p>A standard medieval shirt has been <a href="https://www.sleuthsayers.org/2013/06/the-3500-shirt-history-lesson-in.html">priced out</a> down to the hour: 500 hours to spin the thread, 72 to weave the cloth, 7 to sew it. Without counting anyone touching a sheep or a flax field. At minimum wage, that’s around $4,000. For one shirt.</p><blockquote>579 hours. $4,000. One shirt.</blockquote><p>You think that’s crazy?</p><p>Clothing built at that cost wasn’t a purchase, it was <strong><em>infrastructure</em></strong>. A farm woman in 1800 owned three dresses if she was lucky — one for best, two for daily wear — and each was worn until it disintegrated, then cut down for the children, then rags, then sold to the rag-and-bone man. Nothing was built to expire.</p><h4>Built to Expire</h4><p>Today’s shirt (the red curve) costs less than lunch and isn’t expected to survive a season.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5yR31NU0bbwfuQYSpiFdFg.png" /><figcaption>Built to expire — the commodity version of subscriptions (data from <a href="https://www.google.com/search?smstk=ChhTQjZqZjF1UUYrTS9QMHhyY200WVprUT0QARgA&amp;smstidx=2&amp;q=what+do+we+know+about+the+cost+of+a+shirt+in+workhours+as+a+function+of+time+from+the+time+of+the+luddites+to+today%3F&amp;udm=50&amp;csuir=1&amp;aep=34&amp;kgs=f0bd062e420164e6&amp;shem=agpl%2Caimbispc2%2Caiolsbe%2Casdpe%2Cepsd1&amp;shndl=37&amp;shmd=H4sIAAAAAAAA_3VPMW7EMAxDO94TOmkuenFv6VAUuKcYiq3YQmIrsGX48r9OfVWTrEUBDiQhguLl-_nyFgqhDuAwwyYNEs4EGgm2a3W4ENBjlUxZGZf7y1dUXeunMb33IVRFZTc4SaYSFheva5EkBjnZGrGQ1djSmJGXYc3hVXtEBS_QCeYsHXCUpmebk6ogEyDUyEWBM3Qpc5RWKuAOmFp2ypKPK-VEMO1dZ_ZUh7vzpXnPShVUdnjc7j9P9r-nOWGgasaC2XMOJoiEhYINBT3vk83t8cezez57LN7ePt79euz6BToSd5xHAQAA&amp;shmds=v1_ARwrE20PUxzO24-PoPAzZ0R-moj0DRKcNL8VJY7KX0HH_w1YxQ&amp;source=sh%2Fx%2Faim%2Fm1%2F1&amp;sei=PhRnapC-Np3Ki-gP0_Hg-Qo">here</a>, <a href="https://chatgpt.com/share/6a671c4e-d078-83ed-9f32-ce9d917a660b">cross checked</a>).</figcaption></figure><p>There are no more Luddites because the trade died. It didn’t transform into something else; it ended, inside a single working lifetime. The growth landed elsewhere, and on people who were never weavers to begin with.</p><p>The pride a weaver held in the craft didn’t transfer to the mill floor.</p><p>Zoom out from the loom (the blue curve), and the story reverses. Designers, advertisers, influencers, models, logistics, porters, supply chain managers, retailers, just to name a few (and I deliberately skip tailors). By any industry-level measure, automation didn’t shrink this field. It detonated it. Some would say democratized it.</p><h3>Two, Ten, Maybe Twenty</h3><p>From what I see, I’ll now speculate where we’re going with this. <br>Not now, but sooner than we’d like to think.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7bhBg2PAMAUYwQoD8R7hlQ.png" /><figcaption>Predictions are free. Bets aren’t. (spun <a href="https://docs.google.com/drawings/d/1HEGEWcungcTZA1ohoQaE7l8f0X5_WskKVh-uS3M_4vg/edit">manually</a>)</figcaption></figure><p>Two, out of a hundred people writing code today, would end up contributing to skills and tools that get widely adopted. Unfortunately, “widely adopted” won’t necessarily mean best. Just better communicated.</p><blockquote>Reality check: How many packages are in npm, and how many are used?</blockquote><p>The ratio that transformed loom workers to automated loom engineers was horrid. I’ll take a less horrid rate. Say, ten, maybe twenty — will become software-factory/process managers: composing agents, skills, tools and harnesses into a running pipeline, on behalf of a company, or even a SaaS.</p><h3>Connecting the Dots</h3><p>What will the software factory floor look like?<br>All moving parts are there. Synthesis happens as we speak.</p><ul><li>One codified gate is a checkpoint.</li><li>Compose enough of them and you get a pipeline. Intake, build, verify, ship — stages CI/CD runs. <br>Just extended as further back as to where the work starts.</li><li>Put a few types of such pipelines behind a router — and you cover the lifecycle from ideation to delivery.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dzsRiuVH5guPEyq5NhZtcA.png" /><figcaption><a href="https://www.youtube.com/watch?v=VQy50fuxI34">Forget about loop engineering / IndiDevDan</a>. (<a href="https://www.youtube.com/watch?v=VQy50fuxI34&amp;t=1079s">here</a>)</figcaption></figure><p>Support tickets, product issues, roadmap requests — all funneled through a structured intake flow, not a Jira ticket and a hope.</p><p>Here’s the vid that put it best: <a href="https://www.youtube.com/watch?v=VQy50fuxI34">Forget about loop engineering / IndiDevDan</a>.</p><h3>Talk to My Agent</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/957/1*WslDD27m0Yv7OUf46MbcUA.png" /><figcaption>By the way. You can literally <strong><em>talk</em></strong> to the agent. For free. <a href="https://handy.computer/">see here</a>.</figcaption></figure><p>In show business, “talk to my agent” is a door closing. The agent stands between you and the talent, and decides whether your money worth the time.</p><p>Increasingly, that’s literal here too — and it’s not new, either. The Buffer Zone never went away, it just got a software update.</p><p>Where PMs used to stand between stakeholders and developers, an intake-agent will stand between users and the coding agent. Think of it. A PM-bot following codified Product policies, buffering a dev-bot. Mapping these market-trend tantrums into a ticket, structured enough to survive all the gates downstream.</p><blockquote><em>Somewhere behind every clean ticket, someone talked to an agent first.</em></blockquote><h3>Welcome to the Valley</h3><p>Do the math from the last section forward and it resolves into one number: fivefold. Twenty out of every hundred coders becoming codifiers and process managers. Sooner than we believe, software-factories will make that happen: these twenty will carry the weight a hundred coders used to.</p><p>This headcount balances only if the industry behind them grows to five times its current size.</p><p>That’s still speculation dressed as arithmetic. <br>But the speculation is about the threshold, not the headcount:</p><blockquote><em>What will be the point where running a software factory stops being bleeding-edge practice and becomes professional practice — as ordinary as running CI/CD is today?</em></blockquote><h4>The current Headcount</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d5Y7SCEBvMB-mfPWNbWbug.png" /><figcaption><em>No valley, just yet. (</em><a href="https://fred.stlouisfed.org/series/CES6054150001"><em>source</em></a><em>)</em></figcaption></figure><p>The chart shows no valley, just a mild slope. That’s not the same as no valley coming. The tools are still ripening. Checklists recipes a mid-level engineer can follow for running an agent reliably.</p><blockquote>These checklists are slowly showing up.</blockquote><p>Until then, the philosophy of the software factory is still cutting edge, not common knowledge. And cutting edge doesn’t show up in a bureau labor chart.</p><h3>How Long will the Valley be?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/786/1*XveVbxkw7uhW-JICLWqGFQ.png" /><figcaption>Those along for the ride just lost the seat belts (image from <a href="https://www.kickstartology.com/pandemic-emotional-roller-coaster-is-exhausting/">here</a>)</figcaption></figure><p>Long enough that the question stops being about talent and starts being about appetite.</p><p>Textile had three disruptions: mechanization, computerization, and the arrival of synthetic fiber. Software is getting its version of all three at once — the agent doing the mechanical work, the harness making it computerized rather than improvised, and free open tooling playing the part synthetic fiber played for cloth.</p><blockquote>It’s a tree-shaking event.</blockquote><p>A shakeout doesn’t select for who was best at the old craft. It selects for who’s still standing once the old craft stops paying rent on its own. What comes out the other side isn’t the most skilled twenty percent of today’s coders. It’s the most dedicated, the most devoted, the ones who were never leaving anyway.</p><p>Not those who came along for the ride.</p><p>Maybe you have what it takes to be in the 22%. Maybe all you need is the commitement. Or maybe you’ll have an easier go in the adjacent lane. The time to press an advantage is now.</p><h3>Adjacent, Not Absent</h3><p>The other eighty aren’t necessarily unemployed. They’re adjacent — and this is where the pipeline in <strong><em>Connecting the Dots</em></strong> section stop being architecture and start being headcount.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/620/1*v83otZhDlknd4yB1STFKxg.png" /><figcaption>Still in the park, just not that ride. (image from <a href="https://www.linkedin.com/pulse/you-tall-enough-ride-joni-naugle/">here</a>).</figcaption></figure><p>Leaving code-by-hand isn’t what separates the 22% and the 78% either.</p><p>How many programmers today hand-write assembly? Almost none, and nobody calls that leaving the industry. The 22% will see less code, more policy (and a whole lot more troubleshooting). It’s quite a different job.</p><p>The rest get what growth actually buys: the industry will eventually be able to afford roles it already needed and couldn’t.</p><blockquote>When? How long? That’s everybody’s bet.</blockquote><p>Let’s speculate how that spreads.</p><ul><li>Developers freed from the earlier stages of that pipeline don’t vanish. They move closer to customers — customer success, product, the very stakeholders a PM used to buffer them from entirely. Not managing them. Sitting with them.</li><li>Product and CS feel the shift too. Free of the ticket-writing bottleneck, start prompting the factory intake directly.</li><li>QA gets a second act. It already survived one automation wave; this one asks something new. <br>AI Reliability Engineering is where testcase determinism drops by a magnitude.</li><li>There will be more positions I cannot see from here. The only question is how long it will take them to appear, and who will be relevant to fill them.</li></ul><blockquote>The other eighty were always needed. Growth is what will make them eventually affordable.</blockquote><h3>A Matter of Ownership</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/897/1*AYwrCGNZTN5ZGzUeaQxZ8g.png" /><figcaption>Read the fine print. (<a href="https://app.leonardo.ai/generation/image/close-slightly-worn-photograph-old-talent-agency-76c0dfc0-91af-46ae-a29b-f47adb8f1e61">generated</a>)</figcaption></figure><p>In show business, the agent held the backlog. They decided which auditions you took, which rooms you get, where you perform. The performer didn’t own the schedule. The agent did.</p><p>Flip the pun back to code and the question gets sharper. A coding agent that gets to ship whatever it generates, stops being your tool. It becomes your agent— the one deciding what goes out under your name.</p><p>IMHO — vibe-coding already has this backwards. Approving output because it reads plausible isn’t ownership. It’s taking whatever booking the agent offers and calling it a career. And soon it gets worse: agents will soon decide which tickets even enter the pipeline without human intervention.</p><blockquote><em>The developer who doesn’t own the agent gets owned by it.</em></blockquote><p>Whichever job title survives won’t be decided by “coder” vs. “codifier.” It’ll be decided by who wrote the contract.</p><h3>Conclusion: So, Is Your Place Secure?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DQtTry3LSBXK-VkVy-7Fmg.png" /><figcaption><em>No such thing. The only constant is change. (image from </em><a href="https://www.linkedin.com/pulse/job-security-gone-you-need-manage-your-career-youre-andrew-garner-syxuc/"><em>here</em></a><em>)</em></figcaption></figure><p>The craft that made you proud is being codified out from under you. That’s not an insult. That’s the shift the smart sees and the wise acts upon.</p><p>Your place in the software industry can be secure. Your place as a coder cannot. Few will codify. Even less will code. A bunch more will maintain the processes, composing factories made of ratified codices and tools. The rest move to software-adjacent positions, as soon as the valley ends.</p><p>Put in the work to be one of the few, or start diversifying now. Nobody hires for “still deciding” once the shakeout is already underway.</p><blockquote><em>The agent isn’t coming for your job.</em></blockquote><blockquote><em>It’s coming for your job description</em></blockquote><blockquote><em>— go write the next one yourself.</em></blockquote><blockquote>You may be interested also in my previous post on Future of Work:<br> - <a href="https://osherel.medium.com/i-take-full-responsibility-7fd9547ca6dd?source=user_profile_page---------13-------------90db3ed60cfe----------------------">I take Full Responsibility</a></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/698/0*Zwi7FE74TGP7Xubs.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=24d771611910" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Things Claude could not See]]></title>
            <link>https://osherel.medium.com/things-claude-could-not-see-c1a193fe68d6?source=rss-90db3ed60cfe------2</link>
            <guid isPermaLink="false">https://medium.com/p/c1a193fe68d6</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[observability]]></category>
            <category><![CDATA[grafana]]></category>
            <dc:creator><![CDATA[Osher El-Netanany]]></dc:creator>
            <pubDate>Sun, 19 Jul 2026 16:07:54 GMT</pubDate>
            <atom:updated>2026-07-19T16:07:54.557Z</atom:updated>
            <content:encoded><![CDATA[<h3>TL;DR</h3><p>Harness-engineering moves towards handing the agent an automated verification bar it could iterate against. However, there are fields with an inherent gap between <strong><em>working </em></strong>and <strong><em>usable</em></strong>. This is a story of how I worked out such a gap into a fun Human-AI iterative collaboration.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Slvxnz51dY-cxNYGLRV5gg.png" /><figcaption>Could Not see (<a href="https://app.leonardo.ai/generation/image/humanoid-ai-hands-keyboard-blindfold-cover-a0e7e27a-1912-4af7-b485-82cb57a12e03">generated</a>)</figcaption></figure><h3>The opening shot</h3><p>The acquisition papers were barely dry before the new owner reset expectations. A SLA tighter by two orders of magnitude. And an unpredictable load. Observability stopped being a <strong><em>someday </em></strong>item.</p><blockquote>It happened the moment someone started asking about <strong><em>uptime </em></strong>with a straight face.</blockquote><p>The workload is an AI detection pipeline, processing documents customers submit. Detectors were pointing errors, raising issues, giving insights — saving expensive errors downstream.</p><p>So I tried what everyone does now. Pointed an agent at Grafana and asked for a dashboard. Build it, confirm it returns data, ship it — the same instinct you’d apply to any other software deliverable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*p1xC1K7LnPhy56mtSKph1A.png" /><figcaption><em>200 is not the same as okay. (</em><a href="https://app.leonardo.ai/generation/image/monitoring-wall-showing-rows-green-all-systems-0f355371-20d4-4f84-8249-4597b6404520"><em>generated</em></a><em>)</em></figcaption></figure><p>Alas, you can assert that a query returns 200 and a payload with real numbers in it. You <strong><em>cannot </em></strong>assert that an on-call person reads the right thing from it.</p><p>That gap — between passing and legible — is where this entire story lives.</p><h3>Gather the Data</h3><p>First, there had to be metrics to be processed. This is how the data is gathered from GPU nodes:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1019/1*gSKTzFbjbxhZ11VDKnRTqw.png" /><figcaption><em>Looks obvious. (</em><a href="https://gemini.google.com/app/de891bebe86b928f"><em>generated</em></a><em>)</em></figcaption></figure><p>At boot, each GPU node registers an nvidia-dcgm-exporter daemon — NVIDIA&#39;s own instrumentation for GPU metrics. Swap the vendor and the daemon changes name, not role: watch the hardware, report what it sees.</p><p>An OTel-collector skims that exporter and, formats the metrics in OTel, and ships it to log centralization digestion pipeline, usually ending in Prometheus. Whatever sits underneath — ECS, Kubernetes, whatever orchestrator you&#39;ve bet on — the shape doesn&#39;t change: exporter, collector, time-series store.</p><blockquote>This part is the unglamorous grit. But it’s THE prerequisite.</blockquote><p>And we’re there, on the last link — graphs.</p><h3>Someone Else’s Eyes</h3><p>Before building anything, the responsible move: see what already exists. Grafana’s ecosystem isn’t short on community dashboards. Unfortunately, its the usual quantity vs quality thing.</p><p>Had a single one of them been close, it would have been easy: hand it to a few LLMs, ask them to explain it, scrutinize it, say what an expert would fix. Cross-examine the tool instead of building one from scratch. That shortcut never opened — none of them were close enough to be worth the interrogation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/827/1*bAk3qNt0afKguRM9c6s5MA.png" /><figcaption><em>Not your glasses. (</em><a href="https://app.leonardo.ai/generation/image/someone-trying-stranger-s-prescription-glasses-d99a683a-9ad7-4bc7-90cb-ae025f589bcf"><em>generated</em></a><em>)</em></figcaption></figure><ul><li>Some did not work out of the box.</li><li>Some were coupled with obsolete data gathering mechanisms.</li><li>Some screwed up the metric names.</li><li>Some were too simple and required effort to parse the signal.</li></ul><blockquote>Borrowed eyes see someone else’s normal, not yours.</blockquote><p>So. I had to dig in myself — the long way, all in.</p><h3>Opening Research</h3><p>Sample first. Not the metric names a vendor’s docs promise, not the ones memory suggests — the real names, the real attribute shapes, the real cardinality actually on the wire.</p><blockquote>A monitoring strategy built on anything else is not built on fact, but on hope.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3Ok8TydPn2VoJ6iJJXrFAw.png" /><figcaption>Dig in. (image from <a href="https://bubbleenterprises.co.uk/our-services/the-research-process/">here</a>)</figcaption></figure><p>It happens by asking Prometheus directly — which is where the first seed of the tooling showed up, quietly, before there was any dashboard to speak of.</p><p>It was a shell function Claude could call to sample data and test a query. I built it in two layers: a generic authenticated call against Grafana’s base URL and API token, and a concrete one on top that filled in the actual path, method, and payload.</p><p>The two layers just meant I could add later more operations other than search — and I knew I would.</p><p>Claude acted here as my research assistant.</p><ul><li>First, I gave it access to the search function to sample the metrics.</li><li>Next, I asked it for the canonical GPU-monitoring strategy, pitfalls, alerts, thresholds.</li><li>Then I used an adversary agent to find the holes in it: what’s missing, what’s stale, what’s a known trap dressed up as a best practice.</li><li>And Last — Cross-examined the resulting plan against ChatGPT and Gemini too — nothing here got trusted on a single source.</li></ul><p>I ended up with:</p><ul><li>working and tested Prometheus queries for every KPI involved.</li><li>a hand-wave sense of how each should be shown</li><li>a help/description text that should come with the panel that show it explaining whats actionable about it and in what terms</li><li>a guess at alerting thresholds from what we could see from our data.</li></ul><h3>Then I Tried “to Clode” It</h3><p>Nothing about the ask was vague. It had the Grafana dashboard schema docs. It had the KPI list from the research phase, queries already tested against real Prometheus data. Suggested organization into folding sections. It had a plain definition of what “done” looked like. Everything a well-briefed on-call hire would get on day one.</p><p>So I tried “cloding” it — one prompt, cold and structured, see what comes back.</p><blockquote>Software development is a journey from the unknown to the known. / Kent Beck</blockquote><p>One generation pass doesn’t get to journey. It has to guess every axis at once.</p><ol><li>The result should be valid JSON.</li><li>It should match Grafana’s dashboard schema.</li><li>The KPI-to-panel translation should work.</li><li>And most important — the dashboard should mean enough to a human actually reading it.</li></ol><p>Four unknowns, one shot.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1002/1*7FTnSMPfkqO9D4NKqOB8PQ.png" /><figcaption><em>My spoon is too big / Rejected, Don Hertzfeldt (</em><a href="https://youtu.be/RigRdKqxEiM?t=63"><em>here</em></a><em>)</em></figcaption></figure><p>What came back parsed fine as JSON. But it failed against Grafana’s schema. Fields that don’t exist, a dashboard shaped by pattern and memory instead of the actual spec, despite the spec sitting right there in context.</p><blockquote>Confident. Coherent. Hallucinated.</blockquote><p>With no way to check mid-flight — it was too much the attention mechanism could work out. The errors weren’t a quality problem I could prompt away.</p><p>They were statistically inevitable…</p><h3>To a Valid Dashboard</h3><p>To fix for a hallucinated schema, I built one panel by hand in a sandbox dashboard . Real filters, real query, real thresholds, and a folding row section. I exported it whole, handed it to Claude as a literal reference: here is what “correct” looks like, byte for byte.</p><p>I did one more thing. The tool I’d built for querying grew a second job: deploy a dashboard. I let Claude used it to update the sandbox dashboard. A rejected deploy now came back to Claude, not to me — it would read the error and retry before ever calling me in.</p><p>From that point, schema rejections became rare. And when they happened, they hardly ever reach me. Mechanical correctness stopped being my problem.</p><p>I could focus on On-call usability.</p><p>But fixing the schema problem did nothing for the signal problem. It only cleared the noise off the actual argument.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/838/1*5MpgGcMnUfQIt3ZvrEfT6g.png" /><figcaption><em>A weak signal (</em><a href="https://app.leonardo.ai/generation/image/zoom-mobile-phone-top-right-corner-showing-weak-644872b8-cf48-46de-8c4f-27f0e0b1e8a6"><em>generated</em></a><em>)</em></figcaption></figure><p>The panels were still bad. Even worse than the community dashboards I’d already thrown out two sections ago.</p><p>Now, the sandbox was a full dashboard: It had working cascading dashboard-levels filters — (narrow from “everything” to “this env” or “this one service”). Enough scope that “Valid JSON Schema” stopped being the honest name for this stage. It became “Valid Dashboard.”</p><p>Having a few failed attempts funnelled Claude to the naïve implementation. Spit each curve into the simplest panel that worked. Optimizing for HTTP 201 on the dashboard update, taking no risks. <br>And let the human cognitive of the user do the heavy lifting.</p><p>The dashboard became a deep scroll with help description texts scattered over all panels sending the viewer to cross panels to get a clear indication.</p><blockquote>Passing “is this valid” said nothing about “is this useful.”</blockquote><h3>Editing in the Native Tongue</h3><p>If the tool couldn’t see UX, someone had to. Me.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/686/1*YEiXl9lApp99IR-ft-tH6w.png" /><figcaption><em>Placing the eye — when Picasso does it, it‘s art. (image from </em><a href="https://brooklynrail.org/2025/06/artseen/pablo-picasso/"><em>here</em></a><em>)</em></figcaption></figure><p>In the sense of tooling, what was added here is a function that reads a panel from a dashboard. One Claude could then pipe to a file. Same backbone of authenticated HTTP request, different endpoint (and some json-querying on the result).</p><p>Swap curl for whatever HTTP client you&#39;re comfortable with — node, python, doesn&#39;t matter. The technical change is minor. The big change was the feedback loop around it:</p><p>The agent puts a single candidate panel in the sandbox. From there, either side can make a move. Color changes, a crossed second curve, scale, graph type, a threshold, a label, a better help text, etc.</p><p>I could edit it live, in Grafana’s UI, or I can prompt Claude to make a bigger structural change. Whichever fits the size of the fix: small things are cheaper by hand, big things are cheaper by prompt. Either way, once I’m happy, the agent reads the panel back out and pipes it to disk.</p><blockquote><em>The loop didn’t care who made the last edit.</em></blockquote><blockquote><em>It only cared I ratified it.</em></blockquote><p>Editing live skips a translation hop that describing-then-regenerating can’t avoid. Typing it straight into the field beats explaining it in English and hoping it comes back right.</p><p>What actually matured wasn’t the tooling. It was the order my prompt established.</p><ul><li>First, settle the sandbox and its filters first.</li><li>Then work out one panel at a time.</li><li>And last — compose them all together into a full dashboard.</li></ul><p>Once the full dashboard was deployed, I could optimize screen real estate: tuned for what a human eye catches first, not just what fits in.</p><h3>Compressed Aesthetics</h3><p>The better fixes weren’t reviewing harder. It was compression: deriving one number from few raw curves that only mean something when read together. Then, making it into a verdict . Thresholded, clear, actionable. Sitting at the top of its section.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/861/1*dNjCHOxlpYBdvcLFDM-bCw.png" /><figcaption><em>Claude said all green. I saw red (image from </em><a href="https://www.incredibleseeds.ca/products/sugar-baby-watermelon-seeds"><em>here</em></a><em>)</em></figcaption></figure><p>Example: the GPU fleet’s own node count, tracked as three separate curves — running, desired, pending. Three lines, three colors.<br> I decided to collapse them into one derived curve instead:</p><p>value = desired − running − pending</p><p>Positive means the fleet is short — provisioning is due. Negative means it&#39;s over-provisioned — scale down should follow. Green between −1 and 1, orange out to ±2, red past that.</p><p>That’s the whole trade. The agent gets you syntactically valid, schema-correct — every axis it can check against a spec, every time. Labels, thresholds, colors, what to cross with what — it can propose all of it, confidently. It cannot verify any of it against anything but a schema. That verification lands in human perception.</p><h3>A Dashboard You Can Diff</h3><p>That verification has to land somewhere once it happens — and where it lands was a architecture design choice that led the tooling:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1019/1*VnbZKDLFsCdaXVhG2dYuAA.png" /></figure><ul><li>dashboard.json - base configuration: metadata, timing, the layout shell.</li><li>variables.json - the filters an on-call engineer touches to narrow &quot;everything&quot; down to &quot;this.&quot;</li><li>panels-layout.json determine what panel sits in what section. Kept apart on purpose.</li></ul><p>By this point the tool functions covered the whole lifecycle:</p><ul><li>save a panel from a live dashboard to disk</li><li>push a panel to the sandbox dashboard from disk</li><li>compose a full dashboard from its layout file and panel JSONs</li><li>publish the composed dashboard to the sandbox or to its final destination</li><li>add or edit an alert</li><li>fire a test alert</li><li>tear the sandbox down when after its all done.</li></ul><h3>The Prompt Becomes a Skill</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/794/1*u-mDNubk-vdpAX4j_CNaJg.png" /><figcaption><em>Build up your skills (image from </em><a href="https://careerminds.co.uk/blog/what-is-a-skills-matrix"><em>here</em></a><em>)</em></figcaption></figure><p>What was actually GPU-specific in any of this? Barely anything.</p><p>It does not matter what is your domain: Queues, Network, Databases, Compute, Object-Store — its all the same. Different KPIS, same process.</p><ol><li>Research</li><li>Set up a sandbox with Parameterized filters</li><li>Iterate one panel at a time</li><li>Compose them all together</li><li>Cleanup</li></ol><p>By the time I noticed it, the distance to a real skill was almost nothing. A shell script with the functions already existed. So did a prompt explaining the process — just written GPU-first, with GPU nouns. Becoming a skill took three moves:</p><ol><li>Strip the GPU language out of the prompt</li><li>Add a step at the front for brainstorming the plan before touching a panel</li><li>And move both — script and skill prompt — into .claude/skills/observability-dashboard/.</li></ol><h3>Conclusion</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/795/1*97fcLOkaYk5S1veSmVCgWw.png" /><figcaption><em>Collaboration (image from </em><a href="https://www.unesco.org/en/articles/artificial-intelligence-reflection-its-complexity-and-impact-society"><em>here</em></a><em>)</em></figcaption></figure><p>What was missing was not solvable with more correctness.</p><p>It was UX:</p><ul><li>Colors an scale that bring the details up.</li><li>Deciding which curves only mean something read together, and reducing them to one number.</li><li>Making this number recognizable at a glance.</li></ul><p>These are not facts you feed into a prompt. It’s a human baggage expressed as judgment. Judgement of someone with empathy to the personnel answering pager duty in 3 a.m.</p><blockquote><em>Claude can get you to valid. Getting to legible is still on you.</em></blockquote><p>The skill that came out of this isn’t a dashboard generator. It’s scaffolding, built deliberately around the one seam an agent can’t cross by itself — not because its lazy, but because it has nothing to see with. Nor does it get the feeling of answering an on-call alert.</p><p>Maybe all of that baggage could be prompted into a set of rules an agent could follow without me. However, I haven’t built enough dashboards to put that into words — not in a way that wins every time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/698/1*29J0hDki_OFzXdIGoD8RFg.png" /><figcaption>Thank you for your engagement</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c1a193fe68d6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Do Coding Agents Make Architecture Irrelevant?]]></title>
            <link>https://osherel.medium.com/do-coding-agents-make-architecture-irrelevant-2de1eca45f2b?source=rss-90db3ed60cfe------2</link>
            <guid isPermaLink="false">https://medium.com/p/2de1eca45f2b</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Osher El-Netanany]]></dc:creator>
            <pubDate>Mon, 06 Jul 2026 12:31:04 GMT</pubDate>
            <atom:updated>2026-07-08T08:38:52.440Z</atom:updated>
            <content:encoded><![CDATA[<p>The pitch is seductive. I’ll grant it that.</p><p>The agent reads the codebase — every file, every function, every import — and figures out where to make the change. SOLID principles that took a decade of industry pain to formalize? That was scaffolding for the human mind. The machine has no such limitations. No working memory ceiling. No attention wandering. No <a href="https://workjoy.co/blog/scientific-research-notifications-and-interruptions-negatively-affect-work">23 minutes to regain focus</a> after an interrupt or a useless side track.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fm1FUL3c3dwWmzrGxsYjIw.png" /><figcaption>Architecture of Flow (image from <a href="https://youtu.be/V3TUEeB0kW0?t=329">here</a>)</figcaption></figure><p>I have heard this in consulting rooms. I have read it in threads with many endorsements. Teams shipping features at twice the velocity with half the upfront ceremony. A pull request in the time a planning meeting used to take. Why design the library when the agent can find any page in seconds?</p><p>It is a compelling framing: The agent <strong><em>can </em></strong>read and make sense of it all.</p><p>Every file. Every function. Every line. Every token.</p><blockquote>But Should it?</blockquote><h3>Function over Form</h3><p>Architecture is not a style preference or an aesthetic taste.<br>It is an economic bet: which changes are coming, and how much should each one cost?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kwyD7MD4AvztayNl3dL2XA.png" /><figcaption><em>The blueprint is a bet (image from </em><a href="https://cumminshomedesign.com/blog/2018/5/11/what-are-blueprints"><em>here</em></a><em>)</em></figcaption></figure><p>Every architectural decision is a trade-off. You cannot future-proof a codebase against everything. What you are choosing is: <strong><em>What set of changes should be cheap</em></strong>. <br>E.g. Adding features, improving resilience, scaling under load.</p><p>Other future changes may imply a rewrite. That is acceptable. What is not acceptable is discovering it by accident — paying rewrite costs for changes that should have been routine.</p><blockquote>Architecture is not about the code that exists today. It is a premium insuring the cost of the code that doesn’t exist yet.</blockquote><p>One of these costs used to toll your cognitive load. SOLID was designed for an optimal unit of complexity. One you can wrap your mind around and decide in low effort what to change, what is the blast radius, how to verify it. And stay productive and focused.</p><p>Now, it tolls your AI bill.</p><blockquote>BTW, <br>if you clicked the title and don’t know what SOLID is — <a href="https://www.youtube.com/watch?v=V3TUEeB0kW0">here’s a skimmed recap</a>, and <a href="https://staff.cs.utu.fi/~jounsmed/doos_06/material/DesignPrinciplesAndPatterns.pd">this</a> and <a href="https://desol-tech.com/buckets/Agile%20Software%20Development.pdf">this</a> are how the concept broke out.<br>And no, it’s not applicable only for O.O.P.</blockquote><h3>Selective Reading</h3><p>A human opens a 600-line file. Eyes land on the function name. Traverse to the relevant block. Skip the boilerplate, the utility functions, the unrelated handlers. Read perhaps 40 lines. Close the file.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BWxzvD1xXYPvI3nNzs_1FA.png" /><figcaption><em>Same file. Different bill. (</em><a href="https://app.leonardo.ai/generation/image/two-columns-side-left-labeled-human-file-scattered-0c2d1410-6bad-4e52-bc18-37d1e1daf02e"><em>gernerated</em></a><em>)</em></figcaption></figure><p>An agent that reads a file loads every token into context. There is no skimming at the context level — every character is processed. All 600 lines, before we even get to attention. And those tokens remain in context and accumulate cost across every next inference round-trip.</p><p>This is not a limitation to be patched by better tooling. It is how the context and attention mechanisms work.</p><h3>The Attention Tax</h3><p>Loading every token is the first cost. The second is subtler.</p><p>LLMs do not pay attention uniformly across their context. Comprehension degrades for content buried in the center of a long sequence. It’s called “lost in the middle” — <a href="https://direct.mit.edu/tacl/article/doi/10.1162/tacl_a_00638/119630/Lost-in-the-Middle-How-Language-Models-Use-Long">a known documented quirk</a>. Loaded files degrade as the agent works: each turn adds output, tool results, follow-up reads. A file loaded three turns ago, is now buried in the middle of a sequence the model might not be paying attention to.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PDOfrYs0MJarq4wcpyDg_A.png" /><figcaption><em>There is no good place in the middle (img from </em><a href="https://harshitdawar.medium.com/lost-in-the-middle-the-core-problem-with-large-context-in-llms-651557d7aaba"><em>here</em></a><em>)</em></figcaption></figure><p>The consequence is not hypothetical. The model misreads. Misses a constraint defined earlier in the file. Overlooks a side effect. Produces a change that is locally correct and globally wrong. And the only way to discover that is another pass.</p><p>Each correction pass is itself a read. And because the agent needs the latest revision — not what it loaded three turns ago — it re-reads the same file. Same 600 lines, re-loaded, pushing everything before it deeper into the middle.</p><p>Tokens are the measurable proxy. Their sum represents something more serious:</p><blockquote>The length is inverted to the quality of the reasoning.</blockquote><h3>The Efficient Path</h3><p>The agent does not have to load whole files blindly. It can search — grep a symbol, locate a line — then load only the relevant range. This path is cheap and usually is the default.</p><p>But it stays cheap only if the file is at least well-organized internally. If the search lands inside a 300-line function with mixed concerns, the range the agent reads is not likely to provide a sufficient view. Then the agent faces a forced choice:</p><ul><li>Load another range — risk yet another partial view</li><li>Load the whole file — expensive upfront, one shot</li><li>Assume and Guess!!</li></ul><p>The first two mean subsequent round trips, and growing context across turns. The latter — misalignment. There is no clean option.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1013/1*lGbKdWICWp6eHrbM4G3wlA.png" /><figcaption>Not so obvious (<a href="https://gemini.google.com/app/d19a0fd4c35dbd1d">generated</a>)</figcaption></figure><p>Now take the same logic split across six focused files of roughly 80 lines each — more lines in total. But the agent loads just the files it needs. The codebase got larger, but each task got cheaper.</p><p>Note that a mixed-concern file has more reasons to change — more features touch it, more agents open it. The larger it grows, the more it costs per load and the more often you pay that cost.</p><blockquote><em>The file that is hardest to read becomes the one that gets read the most.</em></blockquote><p>This is what good architecture does at the file level: collapse the choice. Small, focused modular units make the cheap path and the complete path <strong><em>the same path</em></strong>. The better-structured the codebase, the smaller the context the agent needs to reason about a change.</p><h3>They Write Where They Stand</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Am3PjKqbgyEwPD7-qUdBHg.png" /><figcaption>Cha cha cha cha changes…. (<a href="https://gemini.google.com/app/e14da9498b2ca035">generated</a>)</figcaption></figure><p>Agents add code at the touch point. They extend the function that already exists. Append to the file that is already open. Insert a branch where a branch can fit. They do not restructure — not unless instructed to explicitly, and even then, only the piece in “view”.</p><p>No one is tending the whole.</p><p>The consequence compounds. Remember that highest-churn file, the one every new feature touches? Every line added widens the blast radius of the next change. It also raises the cost of (and the probability of) the next read.</p><p>With a human team, this loop runs over months. Until a senior engineer eventually calls it out — “this file is getting unwieldy, we need to split it.” With agents, the same loop runs over weeks. Velocity is symmetric: agents ship code faster, and decay it faster.</p><p>This is not a failure of agent intelligence — the agent has no incentive to look beyond the task. It optimizes locally, as instructed. The failure is structural — the absence of a mechanism that forces anyone to look at the whole.</p><p>Architectural debt with human teams tends to accumulate diverging conventions, stale abstractions, inconsistent patterns. With agents it accumulates sporadic growth.</p><blockquote>The parts you most need to be clean are the ones that get the dirtiest.</blockquote><h3>“But Contexts Are Getting Infinite”</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y-Bz3uaKqRhuSjW14Vj1NQ.png" /><figcaption><em>Moore’s Law is jealous (image from </em><a href="https://www.meibel.ai/post/understanding-the-impact-of-increasing-llm-context-windows"><em>here</em></a><em>).</em></figcaption></figure><p>The counter-argument arrives on schedule: context windows are growing. A year ago, fitting a large file in context was a real constraint. Today, less so. Tomorrow — who knows?</p><p>But. Even if context becomes infinite, inference scales with it. A 600-line file in a 2-million-token window still costs 600 lines of inference. And still puts 600 lines of noise between the model and the thing it’s looking for. Cheap does not mean free. At the scale of an organization running many agent tasks in parallel, “cheap but wasteful” is just wasteful with extra steps.</p><p>And the attention ceiling doesn’t disappear because the window grew. It spreads.</p><h3>As Above, So Below</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KFBlC_47ilOlrgYEE8uynQ.png" /><figcaption>Zoom in, Zoom out (image from <a href="https://news.uoregon.edu/content/study-finds-age-3-kids-prefer-natures-fractal-patterns">here</a>)</figcaption></figure><p>Everything said about files applies at every level of the stack. Focused, well-bounded units with clear interfaces — the principle is scale-invariant.</p><blockquote>Function → File → Module → Service → System → World</blockquote><p>The return of monoliths is worth naming here, because it is sometimes misread as permission to drop internal boundaries. The valid case for the monolith is operational: fewer moving parts, simpler deployment, no distributed failure modes. <br>That argument says nothing about internal structure.</p><p>In microservices, service boundaries are enforced by the network. A call to another service is a hard boundary — you cannot reach inside it by accident. In a monolith, a module boundary is a directory. This is not a border for an agent. But like SOLID, agents default towards monoliths.</p><blockquote>The monolith revival demands higher internal discipline.</blockquote><h3>Locally Rational, Globally Broken</h3><p>Plastic became cheap before the industry learnt to close the loop. The incentive to hardwire the disposal into the system was never introduced. Producers optimized locally — fresher product = more packaging. The cost of disposing the packaging did not show up in the cost of the packaging. It deferred the payment downstream: by municipalities, by oceans, by the next generation.</p><p>The result is the lotus cookie: each individual cookie in its own wrap, a bunch in a sleeve, few sleeves to a pack. No step in that chain was irrational. Every step made local sense.</p><p>That loop is still broken, over 70 years later.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/876/1*ut35tkYUWv07ZNBxU71IMA.png" /><figcaption>Microplastics in the making (image from <a href="https://www.reddit.com/media?url=https%3A%2F%2Fpreview.redd.it%2F300-individually-wrapped-biscuits-v0-vmiup0ldzhs91.jpg%3Fwidth%3D1080%26crop%3Dsmart%26auto%3Dwebp%26s%3D04ce0a6aa82a24be041f594acc2e90fca0c7c147">here</a>)</figcaption></figure><p>AI inference follows the same logic. When token costs drop, the incentive to think about architectural waste drops with them. The engineer who added 80 lines to an already-large file will not see the inference cost. It will rise later, when an agent has to load the whole thing to change two lines. That cost lands somewhere else — on a different ticket, a different person, a different bill.</p><p>The CPUs still process it. The messages still travel the network. The GPUs still infer with it.</p><blockquote><em>The cost didn’t disappear.</em></blockquote><blockquote><em>It just stopped appearing on YOUR ticket.</em></blockquote><p>Cheap does not close the loop. It moves the cost until the CTO and CFO sit in a room pulling hair.</p><h3>Proof of Work</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H8zvR36BUoNCRFhjueNUuw.png" /><figcaption>The code either works or it doesn’t. (image from <a href="https://afteroursinc.com/services/pregnancy-tests/">here</a>)</figcaption></figure><p>Token are one form of cost. Correctness is another.</p><p>An agent writing a test for a focused 50-line function gets immediate, tight feedback: the behavior it changed is proved. When that test fails, the stack trace lands somewhere specific. The function represents one point in the workflow — it asserts its inputs, owns its outputs, and can be reasoned about without reconstructing the whole system around it.</p><p>Consider a test an agent writes when working against a large entangled function. It could either be too broad to be useful or couple with internal structure. When they fail, the stack trace gives you a line number inside a tangle. You still have to figure out which part of the tangle is the offending one.</p><p>Architecture impacts the quality of the agent’s own verification loop. A codebase that is hard to test is a codebase the agent cannot modify safely. This will not stop the agent from modifying it.</p><blockquote><em>Not a style problem. Not a coverage metric.</em></blockquote><blockquote><em>A correctness surface.</em></blockquote><h3>Who Guards the Guards?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/819/1*VIVjEWvabi2u4LHTrSf1Hw.png" /><figcaption><a href="https://en.wikipedia.org/wiki/Quis_custodiet_ipsos_custodes%3F">Juvenal</a> asked it first (image from <a href="https://hcgart.com/products/who-watches-the-watchmen-by-john-dunn">here</a>)</figcaption></figure><p>Agents and humans fail differently. A developer loses the plot — context switches, deadlines, a bad week. An agent never had a plot. It executes the task in front of it, with no incentive to look at the whole. So they optimize locally taking on structural debt.</p><p>Different failure modes. Luckily, the remedy is the same.</p><p>SOLID was designed around the unit of complexity and of interchangeability. That unit is the same regardless of who reads it.</p><h3>All you have to do is …ask!</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vP-Q-2xL2PHo8rXqMQQfxw.png" /><figcaption>You’ll never have a friend like me (image from <a href="https://www.vanityfair.com/hollywood/2019/04/aladdin-genie-footage-cinemacon">here</a>)</figcaption></figure><p>SOLID is not new. It is in the training data. Unfortunately, so is every shortcut taken and rule broken just to meet a deadline.</p><p>Models were trained to serve what gets accepted. More users accept mediocre output than push back on it. Alas — the default is not SOLID.</p><p>Prompting is the entry point. You do not need to understand SOLID in full to ask for it — you only need to know the name. Mere asking already improves the result. Start there.</p><p>Prompt your agents to surface structural concerns before extending an existing file. E.g.: Before extending a file, assess whether this change belongs here. If the file already has more than one main responsibility, propose a split.</p><h3>Hard Stops that are Easy to Roll</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/604/1*nvLc3znQpFYdL58uif062g.png" /><figcaption>Lint it. (image from <a href="https://www.lovetoknow.com/home/cleaning/how-use-lint-roller-basics-clever-hacks">here</a>)</figcaption></figure><p>As you build confidence, encode it mechanically. Lint rules that:</p><ul><li>fail on file size over a configurable threshold.</li><li>fail on functions that are too long</li><li>fail on high module/function complexity</li></ul><p>A lint rule does not require you to understand why the threshold is there. It requires you to be deliberate when you cross it.</p><blockquote><em>Exceptions are fine. Accidental exceptions are not.</em></blockquote><h3>All you have to do is …order a check!</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/882/1*LtN_CYYbNorlOyNU78r6bg.png" /><figcaption>Is everything in place for the next guest? (<a href="https://gemini.google.com/app/fbf90b34fd47984a">generated</a>)</figcaption></figure><p>Things that cannot be checked mechanically can still be checked semantically. Run an AI reviewer in CI or during development using an adversary agent.</p><p>Not every PR warrants a full architectural review.<br> Consider triggering one, for example, when:</p><ul><li>a file grows past a threshold</li><li>a function grows significantly</li><li>the number of imports in a module increases sharply</li><li>a single PR touches a high number of files</li></ul><p>When the review runs, the questions worth asking go beyond logical correctness. E.g.:</p><ul><li>Does this change leak concerns across module boundaries?</li><li>Are new coupling patterns introduced?</li><li>Has the file’s primary responsibility drifted?</li></ul><h3>The guard gets a new assignment</h3><p>This is not a claim about human irreplaceability. It is a claim about intent.</p><p>Someone has to decide what the structural constraints are, encode them as enforceable rules, and put those rules in the path of every agent. Once that chain is up — it runs without ongoing human involvement.</p><blockquote>intent → lint rule → CI gate → agent behavior</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iIkbpq7MCewnkHJ8riMIIg.png" /><figcaption>Don’t fall. (image from <a href="https://youtu.be/nXIdmW4Hau0?t=45">here</a>)</figcaption></figure><p>IMHO, this is the most underrated configuration decision in an agentic workflow. Not which model to use. Not which tools to enable. What structural constraints to enforce, and what to enforce mechanically.</p><p>The teams that answer that question deliberately ship faster and decay slower. The ones that don’t — get to discover the answer the expensive way.</p><blockquote><em>The guard needs guarding. Set it up once. Let it run.</em></blockquote><h3>Conclusion — control the Rate</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qCyZepIcRRqA00jkIiKcWg.png" /><figcaption>Better Conversion Rates (image from <a href="https://www.nyctourism.com/places/currency-exchange-international-upper-east-side/">here</a>)</figcaption></figure><p>The claim was: agents handle complexity, so architecture matters less.</p><p>The reality: agents read everything they touch, write where they stand, and optimize for the task in front of them. That makes architecture matter more — not as a human aesthetic, but as a cost surface, a correctness surface, and a structural constraint on how fast things can decay.</p><p>The principles are unchanged. The reason you need them is sharper.</p><p>Agents didn’t make architecture irrelevant. They made the cost of skipping it legible in a new currency.</p><blockquote><em>The machine reads everything.</em></blockquote><blockquote><em>Make sure what it reads is worth reading.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/678/1*IaYF2spqV7mr2SlAmO-Zig.png" /><figcaption>thank you for your engagement</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2de1eca45f2b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My Agentic Learning Loop]]></title>
            <link>https://medium.com/israeli-tech-radar/my-agentic-learning-loop-401690fa461d?source=rss-90db3ed60cfe------2</link>
            <guid isPermaLink="false">https://medium.com/p/401690fa461d</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[trends-and-insights]]></category>
            <category><![CDATA[ai-and-ml]]></category>
            <dc:creator><![CDATA[Osher El-Netanany]]></dc:creator>
            <pubDate>Mon, 29 Jun 2026 06:56:40 GMT</pubDate>
            <atom:updated>2026-06-30T14:29:18.219Z</atom:updated>
            <content:encoded><![CDATA[<p>Astonishingly, agentic workflows are actually a solved problem dressed in new clothes.</p><p>Agentic systems feel revolutionary. They produce output. They chain actions. They make decisions. They <em>do</em> things. But the learning loop underneath them? That’s so old it&#39;s totally neglected.</p><blockquote><em>What’s new is the speed at which it runs.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LqCAwxo-oRegQwgk3rkx5Q.png" /><figcaption><em>wheeee………. (</em><a href="https://app.leonardo.ai/generation/image/comfy-furnished-plastic-pet-rodent-box-nice-mouse-3da5ee38-5810-42bf-8c9c-589730831e07"><em>generated</em></a><em>)</em></figcaption></figure><p>It’s even more dazzling because people expect the learning to be in the wrong place and complain to each other about who moved the cheese, ending each day none the wiser.</p><p>In this article I’ll give you a shot at this wisdom. I’ll show you where I find my learning and why it&#39;s not where you think it is.</p><h3>Premium intelligence, zero wisdom</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1021/1*XoNncyAm7QcZu-B7H4IntA.png" /><figcaption>Mirror, mirror, on the wall, who’s the wisest of them all? (<a href="https://app.leonardo.ai/generation/image/person-looking-mirror-reflects-own-face-code-29aa9fdc-087b-4b25-933a-b467fefc49da?utm_source=share_asset&amp;utm_medium=copylink&amp;utm_content=image">generated</a>)</figcaption></figure><p>Our industry, with all ups and downs, doubles in size roughly every five years.</p><p>Think about what that means. At any given moment, half the software workforce has less than 5 years of experience. We are in a perpetual state of inexperience.</p><p>AI agents will make it worse. They lower the entry bar. They widen the doors. The next up will be bigger than anything we’ve seen—a wide generation entering the industry with premium access to technical intelligence and missing access to human wisdom.</p><p>What do we learn from all this?</p><blockquote><em>This time it will be worse.</em></blockquote><p>Not because agents are bad. But because we have never had such a wide gap between what the tool can do and what the operator understands. The tool accelerates output. But output without quality is noise. A workflow without a feedback system is brute force.</p><p>The learning loop—the system that turns experience into judgment—has always been the invisible advantage: The difference between an actor that grows and one that repeats the same year ten times.</p><p>This piece is about the structural shift in how we learn inside a software system. And why, if we don’t get the loop right this time, the gap between intelligence and wisdom will become a chasm.</p><p>Let’s break it down.</p><h3>The First Industrialized Learning Loop</h3><p>Agile, obviously. That should have been an easy guess.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JvobIgzJVkN1JtnvLZ7_ew.png" /><figcaption><em>Stand-ups: because nothing says “inspect and adapt” like standing in a circle. (</em><a href="https://app.leonardo.ai/generation/image/professional-photo-scrum-board-looks-suspiciously-f6ed256c-e342-4d90-8e70-d9fcfa9661e0"><em>generated</em></a><em>)</em></figcaption></figure><p>I first met Agile in 2005. I bought into it immediately with dreaming eyes. A premise that says that every day you become better—what&#39;s not to love? I admired it. I evangelized it. And I watched it crashing down, misused to oblivion.</p><p>Here’s the obvious thing—the kind of obvious you only notice when you say it out loud:</p><blockquote><em>IT stands for Information Technology.</em></blockquote><p>There was a time when these two letters were an indication of quality—worn like a badge of an elite unit, reserved for the best. It’s laughable to think about it like that today.</p><p>But our trade is information. We are information <em>mongers</em>. People forget that</p><p>The raw material of our craft is knowledge — not code, not deployments, not tickets. Code is a vessel for captured decisions. Deployments apply these decisions at scale. Tickets are decisions in queue.</p><p>The core question of any workday is, &quot;<strong>What new information have you produced today that makes tomorrow better?&quot;</strong></p><p>Agile tries to enshrine this question into the calendar using its jargon of sanctity. The retrospective may be hooded as a ceremony, but. In fact, it is an explicit extraction mechanism—a structured attempt to harvest the information execution produced. Before it decays…</p><ul><li>The Scrum retrospective: sprint-based extraction.</li><li>Kanban: extraction at end of each task.</li></ul><p>Different cadence, same architecture:</p><blockquote><em>work → reflect → adjust </em>→<em> repeat</em></blockquote><p>That cadence is a design constraint, not a preference.</p><ul><li>Too frequent? overhead consumes the savings.</li><li>Too rare? Information decays before it produces insights, so no insights are applied.</li></ul><blockquote><em>Retrospective = information extraction from experience stream.</em></blockquote><p>Not a ceremony. Not a meeting about feelings.</p><p>What actually mattered in agile—the thing the industry systematically gutted—was the feedback loop built into execution. The work was not the output. The learning from the work was.</p><p>There was an assumption so obvious to all agile evangelists but totally transparent to all the rest: If you keep improving, you will deliver faster and better. Agile heard <em>improving yourself </em>or <em>improving the process</em>. All the rest heard <em>improving the product</em>. They could have all been right if they agreed on one principle.</p><h3>The product nobody owned</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/832/1*Z_s2vbife9FIxHgmyPnycA.png" /><figcaption>Catch!! (image from <a href="https://fortscott.biz/news/opinion-the-government-is-here-to-protect-you-from-heating-toss-hot-potato">here</a>)</figcaption></figure><p>Think about it. A team’s workflow—stand-ups, retros, planning, and grooming—is a system they build and maintain. It has requirements (What does the team need?), bugs (Why is this meeting a waste?), and technical debt (rituals that outlived their purpose).</p><blockquote><em>In Agile, The team is the product owner of their own process.</em></blockquote><p>That message never landed. People still treat it as some else’s problem. Some manager. Some scrum-master with an industrial certification 16H training. Something you succeed despite of.</p><p>And when the industry neglected that product and focused 100% on the business—it was clear that “agile is not working.” Because even if &amp; when products improved, the process stayed wasteful and clunky. Adding more cargo rituals obviously does not help.</p><p>Alas, most Agile implementations kept the meetings and dropped the learning. The standup became a status report. The retrospective became a complaint session at best and was the first to go.</p><p>The process became a ritual. Valuable information—failures, surprises, friction—became noise people learned to soldier through. Insight evaporated.</p><blockquote><strong><em>Agentic without learning = cargo-cult at higher speed.</em></strong></blockquote><p>IMHO, most will repeat the failure. But the mechanism exists for those who want to use it.</p><h3>System of Learning</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5GK_RDSgR3hRK2rqYeVQzQ.png" /><figcaption><em>The ice doesn’t learn. The skater does. (image from </em><a href="https://youtu.be/XS0de5ka3v0?t=1112"><em>here</em></a><em>)</em></figcaption></figure><p>The model does not learn.</p><p>I state it plainly because it is still widely misunderstood. After training completes, inference is a static execution layer. The weights are frozen. Every improvement you observe over time comes from one of two sources: a new model release or changes in your system.</p><p>That second source is the one you control.</p><p>The adaptive layer in agentic systems is not the model — it is you and your context.</p><blockquote><em>User + context = adaptive layer. <br>The model is infrastructure.</em></blockquote><p>When output degrades, the instinct is to blame the model. Sometimes that is right. More often the context drifted, the prompts degraded, or the system accumulated friction that was never cleared. The model is the same. The system changed around it.</p><p>And unlike model weights—which you cannot touch—the system is yours to improve.</p><blockquote><em>The model is a commodity. The system around it — that’s your competitive advantage.</em></blockquote><h3>The Capacity Model</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/950/1*2zYc0eu_4ROOeGKoOnKtUw.png" /><figcaption>Message in a bottle(neck) (<a href="https://d2ok7q2ss7z16i.cloudfront.net/upload/images/june2026/image_1782250829885.png">generated</a>)</figcaption></figure><p>Every agentic session runs against two bottlenecks. Understanding both is the prerequisite for improving either.</p><h4><strong>Bottleneck 1: Human review boundary.</strong></h4><p>Every agent output that reaches you requires a judgment call. Approve, correct, or redirect. Every correction is an implicit review cycle. Every re-prompt is a micro-review. The frequency of those cycles directly determines your throughput.</p><p>Better prompts reduce review frequency. Better system design reduces review density. The goal is not zero reviews — reviews are how you keep quality. The goal is reviews that are not redundant.</p><blockquote><em>Every correction you ask for is a useful signal. The question is whether you capture it.</em></blockquote><h4><strong>Bottleneck 2: Budget constraint.</strong></h4><p>Token cost limits execution scale. Inefficient loops burn the budget. Redundant retries burn budget. Oversized contexts burn the budget. Efficient roundtrips enables parallelization and reduces the per-unit cost of output.</p><p>The system-level math is simple:</p><blockquote><em>productivity ∝ budget utilization / review cycles</em></blockquote><p>You can improve either variable independently. Improving both simultaneously compounds the problem.</p><h3>What Actually Improves</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/894/1*OXD__NUj0NfEd8tFNtlduA.png" /><figcaption><em>Absorbs better (image from </em><a href="https://blog.dixiebellepaint.com/scrubby-soap-the-ultimate-cleaning-tool/"><em>here</em></a><em>)</em></figcaption></figure><p>I spent a long time looking for the wrong things.</p><p>I optimized prompts. I restructured manifests. I wrote elaborate system instructions. And some of that helped. But the biggest gains — the ones that actually moved the needle of happiness — were mechanical, not conceptual.</p><p>Here are a few examples of daily friction:</p><ul><li>Agent misunderstood instruction—triggering a re-prompt loop</li><li>Agent uses wrong tool command syntax, triggering retries.</li><li>The agent enters debugging cycles on ad-hoc generated commands</li><li>Agent enters debugging cycles on preventable errors of known edge-cases</li></ul><p>Many of them repeat the same correction loops across sessions.<br>Every correction is a signal. With most people, most of it is discarded at session end.</p><blockquote><em>The difference is in whether the signal is captured or wasted</em></blockquote><p>The objective is reducing the entropy of that execution surface — the surface area where tool calls, instructions, and responses can go wrong. Mechanical improvements reduce that surface. Conceptual improvements are often invisible to it.</p><p>Many of these are repetitive operations that can be solved once and formulated into a utility that agents are then instructed to use. For tools that are private to a skill or to a project skill, I use scripts in the skill directory. For generic things — entries in a Taskfile.yml in my home directory or the project directory.</p><p>This is where improvement is most tractable and least glamorous.</p><p>I raise a counter every time an important tool is used. This makes the improvement, if not measurable, then quantifiable.</p><h3>Sharing My Setup</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*abSKXylJgTwqLxVvW6P2Jg.png" /><figcaption>look inside (<a href="https://app.leonardo.ai/generation/image/envelope-ais-secret-receipt-handed-viewer-76c25699-4d62-424c-83e8-f1943cc76cb7">generated</a>)</figcaption></figure><p>This is a generalized derivation I could cut from my own setup:</p><ul><li><a href="https://github.com/osher/my-learning-loop">https://github.com/osher/my-learning-loop</a></li></ul><p>I did my best to make it:</p><ol><li>generic, unopinionated</li><li>self-contained</li><li>works out of the box</li></ol><blockquote>The gap between my setup and this generic layer is that my setup refers my concrete opinionated tools specifically. <br>E.g. I use <a href="https://taskfile.dev/">Taskfile </a>a lot, and why I do will get someday a post of its own. But other people might do things differently, so accept my inspirational tested-to-a limit humble best effort…</blockquote><p>The setup is based on two core skills: wrap-up and level-up.</p><h3>Time to (run the) Wrap-Up</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/667/1*y-sq2iogfWYZBoMZvXp67Q.png" /><figcaption><em>Dear diary: today my agent was lost, and so was I (image from </em><a href="https://www.facebook.com/groups/1995526557527417/posts/2083424552070950/"><em>here</em></a><em>)</em></figcaption></figure><p>In my setup, it is a skill you call before compaction or before session end. Compaction will drop the very signal you want to capture.</p><p>The wrap-up is not automatic. This is load-bearing. This requires discipline — to run it before information is lost.</p><blockquote>Not process. Discipline.</blockquote><p>Actually, the transcript is not lost. Most agents keep an on-disk record of every session. But retroactive extraction from a raw transcript is a different task than in-session extraction — and a harder one. Every correction, every re-prompt, every friction event is still there. It is just wrapped in an expanding layer of noise. Until it is compacted away…</p><p>Compaction treats these re-prompts and debugs like most developers do—like noise.<br>If you did not collect it while it was alive in context—it does gets lost.</p><p>In practice: manual invocation — a habit, not a reminder. The constraint is fixed: <strong>call wrap-up before the session ends, or pay the retroactive processing cost instead.</strong></p><blockquote>The <em>/wrap-up</em> skill — see <a href="https://github.com/osher/my-learning-loop/blob/main/skills/wrap-up/SKILL.md"><em>here</em></a>.</blockquote><h4>The extraction</h4><p>The extraction is simple: it asks the agent to go over all the links in the context chain and:</p><ol><li>Detect friction — what slowed execution, required correction, or produced unexpected results.</li><li>Extract learnings—distill the friction points into actionable signals.</li><li>Format them into a *.level-up.md artifact — one next improvement cycle can consume.</li></ol><p>The maturity curve is worth knowing. First sessions: mostly mechanical improvements — tool commands, instruction formatting, response structures. Then prompt and prose improvements. Then a phase of mostly false positives — things that look like signal but are not. Finally: no actionable findings, where the wrap-up ends with a celebratory banner.</p><blockquote><em>Diminishing actionable insights over time is the success signal.</em></blockquote><blockquote><strong>Note: </strong>Anthropic provide<em>s the </em><em>/insights skill, that goes over the sessions from all your projects and provides an HTML report of insights about your usage. It cost me about $3 ov</em>er almost 100 sessions — which means, they have the facilitation layer that peels the noise and serves to the LLM a cost-effective format. The skill then aggregates it and gives a nice report with some coaching tips. However, the aggregation looses the private case, generalizes the learning to high-level tips and ignores the project/user level tooling.</blockquote><h3>Level-Up — The Improvement Cycle</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nx8sTC4A1VD9Psamb9CWrA.png" /><figcaption><em>One step up at a time (image from </em><a href="https://goldrecordoutlet.com/shop/led-zeppelin-gold-45-record-limited-edition-laser-etched-wsongs-lyrics/?srsltid=AfmBOoqXbu95nA0v9_ifwiX6tH9JcwTcb45nXsQDxhRTR1QXcfg6BwQX"><em>here</em></a><em>)</em></figcaption></figure><p>The level-up skill consumes wrap-up artifacts and routes improvements into the appropriate layer.</p><p>Level-up artifacts are not notes, in their best form executables—instructions for modifying the system. They say: <em>“Here’s what I learned. Here’s how to apply it. Here’s where it goes.”</em><br>In their worst form—they should say, “<em>Here’s what happened. Here’s what I learned. Did not have context space to investigate deeper.&quot;</em></p><p>The routing is where the mechanics get interesting. Each learning item translates to a learning:</p><ul><li>a standing preference lands in CLAUDE.md</li><li>a reusable execution pattern gets promoted into a skill</li><li>For repetitive operations go to the skills auxiliary scripts or the user task library</li><li>A hook change updates tool config.</li></ul><p>Each learning type has a known destination. The process applies them in order, confirms each one, and marks the item done in the file.</p><p>Nothing lands automatically. I confirm what gets applied before it does.</p><blockquote>The <em>/level-up</em> skill— see <a href="https://github.com/osher/my-learning-loop/blob/main/skills/level-up/SKILL.md"><em>here</em></a>.</blockquote><p>The cadence question is answerable:</p><ul><li><strong>Daily</strong> is a good baseline. Skipping it is incurring technical debt: The further the level-up from the wrap-up — the less I remember about what was the experience I’m trying to fix.</li><li><strong>High-impact insights</strong> can be applied immediately — do not wait for the next cycle.</li><li>A specific level-up file can be targeted directly when the next session depends on it.</li></ul><h3>Conclusion</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mvVCQ9ZNcxvLPLHyYC2Zjw.png" /><figcaption><em>Quiet. The knowledge is working. (image from </em><a href="https://bookish.netgalley.com/bookish-lifestyle/09/2025/library-terminology-how-to-utilize-your-library/"><em>here</em></a><em>)</em></figcaption></figure><p>You are the custodian of a knowledge system. Some of it is shared with your teammates in project repos; some of it is entirely yours.</p><p>An engine without maintenance degrades. Not immediately — gradually, then suddenly. You can have the best engine in the world. If you never change the oil, it seizes.</p><p>A library without a librarian loses findability. Information decays not because it disappears—but because it becomes hard to find.</p><blockquote><em>Keeping the library functional is as important as the knowledge it holds.</em></blockquote><p>The wrap-up is the end-of-day reconciliation. The level-up is inventory management.</p><p>Your goal is always have a good answer to:</p><p><strong>What information did you preserve so tomorrow starts ahead of today?</strong></p><p>If the answer is “nothing”—you are on the same spot in the same treadmill.</p><h3>P.S. — For the practitioners</h3><p>If you’re building your own agentic workflow, start here:</p><ol><li>Establish a wrap-up ritual. Without it, the loop doesn’t close.</li><li>Track your mechanical friction. That’s where the leverage is.</li><li>Route every insight into a level-up artifact. Make improvements permanent.</li><li>Watch for diminishing returns. That’s how you know it’s working.</li></ol><p><strong>Pro-bonus if you actually implement this and prove me wrong about something.</strong></p><p>I appreciate your engagement and time ❤</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=401690fa461d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/israeli-tech-radar/my-agentic-learning-loop-401690fa461d">My Agentic Learning Loop</a> was originally published in <a href="https://medium.com/israeli-tech-radar">Israeli Tech Radar</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Controlling Migrations — of DBs]]></title>
            <link>https://medium.com/israeli-tech-radar/controlling-migrations-of-dbs-ad06ea5944f7?source=rss-90db3ed60cfe------2</link>
            <guid isPermaLink="false">https://medium.com/p/ad06ea5944f7</guid>
            <category><![CDATA[database-migration]]></category>
            <category><![CDATA[data-management]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[full-stack]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Osher El-Netanany]]></dc:creator>
            <pubDate>Tue, 16 Dec 2025 11:04:18 GMT</pubDate>
            <atom:updated>2026-05-03T12:22:58.157Z</atom:updated>
            <content:encoded><![CDATA[<h3>Controlling Migrations - of DBs</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B2B8lkxp6NZMlT0ZJhCv3g.png" /><figcaption>Mr. DB: Hello, can I come in?</figcaption></figure><p>DB Migrations — this phrase brought over the years pain to the face of many IT operatives. The core of most IT businesses is their data. When data is managed in an error-prone slappy fashion — errors will happen.</p><p>I’d expect that after 55 years of working with relational databases we’ll settle for some best practices. But still , when it comes to DB migrations — I’m surprised. As a consultant — I get to meet teams that are very close to shoot themselves in the foot.</p><h3>DB Migration — not Data Migrations</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*CK58TvfliGM9SIQY" /><figcaption>Data in transit</figcaption></figure><p>It has been a while since my previous post. All this GPT era is very dismaying for me. But I decided this post is necessary because when I searched for DB migrations, I got results about Data Migration tools.</p><p>Tools like those that manage Data Lakes and Data Pipelines — ETLs, ELT, etc. These processes port data from one place to another, from one form to another. Making data more accessible and extracting from it insights. <br>…<strong><em>None </em></strong>of all that is relevant to the subject!</p><p>What I’m interested in here is managing the <strong><em>Structure </em></strong>of the database as the software that uses it evolves.</p><p>But more importantly -</p><blockquote>doing that in the modern and reliable GitOps manner</blockquote><blockquote><strong>DB Structure </strong>= schemas, tables, fields, indexes, views, stored-procedures, users, grants, perms, etc.</blockquote><h3>What’s in this post</h3><p>This post is in 3 parts</p><ul><li>theory — the reasons and my humble manifest for the best practice</li><li>practice — showcasing a NodeJS &amp; TypeScript implementations, and mentioning generic tools as well.</li><li>pro-tip — how to get an already existing project on board</li></ul><h3>DB Migrations Control</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9MvpEcJtAs-xq6FR" /><figcaption>Did you pack by yourself?</figcaption></figure><p>Modern and reliable DB migrations control in a gitops manner means:</p><ol><li>humans decided <strong>if &amp; when </strong>to do perform DB migrations, and automation takes care of all the rest</li><li>Automated <strong>proofing </strong>of the migration</li><li>Guarantee <strong>system integrity</strong> in all cases (including failovers)</li><li>All in a cohesive <strong>maintainable </strong>and <strong>extensible</strong> way</li></ol><p>Lets break it down</p><h3>Concerns of DB migrations</h3><h4>1. Humans decide. Automation Act</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/905/1*RcUNtKbMiw1KvlNjOsZnWg.png" /><figcaption>A human decision</figcaption></figure><p>Once the decision is done —the rollout is committing. Then, the process should flow using a predictable reliable and deterministic automation.</p><p>Traditionally, a gitops flow means, the human decision is communicated using a merge to a base branch. As such it can be gated with automatic proofing.</p><p><strong>Implications:</strong></p><ul><li>The migrations should be organized in a DB Migrations project that is managed in a git repo.</li><li>Migrations implementation should rely on a stable and fully automated migration automation tool.</li><li>Migrations modify the <strong><em>form of the database and the form of the data in it</em></strong> — also referred as a version of the database structure.<br>ℹ️ not to be confused with the version of the DB engine.</li><li>The chosen migration automation tool should be able move to a target desired version. It could be forward or backward. For this — it must be aware of the version of the database structure the database is at.</li></ul><h4>2. Automated proofing of the migration</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Y9p7N7qPMqkjDCeV" /><figcaption>An automatic Rollout</figcaption></figure><p>Automatic proofing comes hand in hand with human proofing in peer reviews.</p><p>The migration files should be in a format that can be proofed by:</p><ul><li>verifying syntax, form, security requirements</li><li>verifying object names and logical structure</li><li>verify it runs and working as expected — executing on a test env!</li></ul><p><strong>Implications:</strong></p><ul><li>manage a ledger of migrations in the migration project, organized by order.</li><li>proof the entire project using static code analysis tools: lint, security checker</li><li>run the migrations on a test environment.<br>Given we have all the migrations — running all of them on an empty DB will result with the last DB structure version.<br>ℹ️ prefer to code an indication of success in addition to the exit code of the tool. E.g. — seed the DB with some data and connect to it a service, see that it works.</li><li>rolling back all steps should result with an empty DB<br>(except the table the tool uses to track applied migrations)</li></ul><h4>3. Guarantee system integrity in case of failure in rollout</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*LSwwDsUO9D7MGzjj" /><figcaption>Automatic checkup</figcaption></figure><p>In simple words — perform a rollback in case of error during the automated rollout or the post-rollout checkup.</p><p>But not only when the rollout fails. Lets assume now the rollout was successful. And yet — <strong>some KPIs start dropping!</strong></p><p>This could happen for many reasons:</p><ul><li>The version rolled a change that is not well-accepted by users.</li><li>The version broke integration with another system.</li><li>A configuration error that is visible only on production.</li><li>A hidden rollout error.</li><li>and more…</li></ul><p>For this, the practice should guarantee the ability to revert to the functional state before the rollout. It should do that <strong>without losing data </strong>— which rules out any recovery based on backup and restore. This because data that was created while the new version ran is not present in the backup.</p><p>In the past we used to restore a backup and try to complete the data created since the dump was taken from logs — which usually was manual and painful…</p><p>For this, migrations should implement <strong><em>two </em></strong>ways:<br> up — promote a DB to the form that of the target version, <br>and<br> down — idempotently and reliably demote a DB to the form of the previous version.</p><p><strong>Implications:</strong></p><ul><li>In the default execution mode, the tool should upgrades a DB to the latest version of the DB structure.</li><li>The tool should use the traditional <strong>exit-codes </strong>to communicate success/failure. <br>This assures that higher level automation tools (e.g. provisioners, orchestrators and/or CI pipelines) are able to respond to faults to guarantee system integrity.</li><li>When rollout fails and/or KPIs drop — execute rollback.</li><li>The default <strong><em>rollback </em></strong>operation is to take one step back to a previous version.</li></ul><h4>4. Maintainability &amp; Extensibility</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VgcRUmNVB9L9X_rcULsYog.png" /><figcaption>Mr. DB’s Beauty Salon</figcaption></figure><p>The migration files should be in a format that is comfortable for the teams to work with.</p><h4>Implications:</h4><ul><li>choose a language the team is familiar with.</li><li>Use IDE setup that offer syntax highlights, type-check and auto-completions</li><li>facilitate running the migrations project locally, preferably against local databases.<br>ℹ️ developers should be able to test the migrations against edge-cases of partially executed migrations.<br>If a case becomes common — add it to your proofing automation.</li></ul><h3>The Manifest</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/858/1*LRcR8KlEuOwrCkDMc7wbEg.png" /><figcaption>In IaC we trust</figcaption></figure><ol><li>migrations should be organized in a project.<br>It can be a part of another project that consumes the DB exclusively.<br>Ideally — it will be a project of it’s own, published as its own artifact.</li><li>migration projects should use language and form that is comfortable for the team. E.g. supports IDE enhancements, easy to develop and run locally.</li><li>migrations should be built as a ledger (like git and blockchain are).<br>each migration assumes a deterministic successful state of its previous.</li><li>each migration should be expressed with an up and down (or apply and a rollback). This to let move up or down the ledger by need.</li><li>applied migrations should be tracked and persisted — so the tool can be <strong>idempotent</strong>. The recomended way is a dedicated table in the target DB.</li><li>the tool should communicate success/failure using exit code. <br>The higher level automation should respond to error states and guarantee system integrity.</li><li>applying all migrations on an empty DB results in latest version. Demoting back all of them results in an empty DB.</li><li>the migrations project should be validated by CI using all available validations: <br>- syntax<br>- form<br>- structure<br>- functionality.<br><strong>The bare minimum is the following two functional checks:</strong><br>- running all the migration on an empty DB ends with the latest DB structure version<br>- demoting all migrations on a DB of latest structure version ends with an empty DB.</li></ol><h3>Tools that implement the manifest</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7o5DHueK-I_7fmvSvzvlng.png" /><figcaption>Tools of choice</figcaption></figure><p>There are many tools that implement this theorem. <br>Most my customers’ stack nowadays is based on node.js and TypeScript.</p><p>Let’s see the current offering on this stack:</p><ol><li>knex cli (<a href="https://knexjs.org/guide/migrations.html#migration-cli">link</a>)</li><li>sequelizer cli (<a href="https://sequelize.org/docs/v6/other-topics/migrations/">link</a>)</li></ol><p>The following are two Honorable mentions. I personally like them less, because these options come with an opinionated workflow that impacts the development of the services as well. However, they make a good choice if your architecture anyway couples your services with an ORM layer.</p><ol><li>TypeORM (<a href="https://typeorm.io/">link</a>)</li><li>Prisma — (<a href="https://www.prisma.io/">link</a>)<br> ⚠️ specific to postgres.</li></ol><p>Outside the Node.JS stack — you can find:</p><ol><li>flyway - SQL centric, simple. Recommended when the team is comfortable with raw SQLs. (<a href="https://www.red-gate.com/products/flyway/community/">link</a>)</li><li>liquibase - complex swiss knife for advanced DB setups. (<a href="https://www.liquibase.com/">link</a>)<br>IMHO — overkill and does not justify the learning curve.<br>Justified mostly when you need atomic cross-db migration support.</li></ol><h3>Delivery method</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*MtVjzKL6VUhuc-sf" /><figcaption>Judging a box by its cover?</figcaption></figure><p>A delivery method in our case would be any form that will let us run the migration projects in CI/CD workflows.</p><p>The most popular delivery method is to pack the project as a docker container. That should be the preferred method. It makes the delivery reliable, portable and versatile. It is versioned, self-contained, securable, and reusable.</p><ul><li>You can run it as a CLI.</li><li>You can run it as a k8s job and deploy it with kubectl, helm or ArgoCD.</li><li>You can use it as a base for GitHub-actions step / Gitlab job</li></ul><p>You can also deliver it as an npm package on your private registry, or any other kind of files-repository. Or you can clone the repo, install its dependencies and run it from CI .</p><p>But since you’ll have to provide network access to the DB and move secrets over the network — the k8s job is the most preferred and secure method.</p><h3>Kickstart Examples</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/706/1*IglV0gqsQGcoen-0d-gMag.png" /><figcaption>Mr. DB presents: All-star Revision!</figcaption></figure><p>Here are the entry-points for the mentioned projects:</p><ul><li><a href="https://knexjs.org/guide/migrations.html#transactions-in-migrations">Migrations | Knex.js</a></li><li><a href="https://sequelize.org/docs/v6/other-topics/migrations/#migration-skeleton">Migrations | Sequelize</a></li><li><a href="https://www.prisma.io/docs/guides/data-migration">Migrations | Prisma</a> and <a href="https://www.prisma.io/docs/orm/prisma-migrate/workflows/generating-down-migrations">Down Migrations | Prisma</a></li><li><a href="https://typeorm.io/docs/migrations/why">Migrations | TypeORM</a> — and <a href="https://typeorm.io/docs/migrations/reverting">Down Migrations | TypeORM</a></li></ul><p>Updated: If you want to write down-migrations mannually:</p><ul><li><a href="https://orm.drizzle.team/docs/migrations">Migrations | DrizzleORM </a>— (and <a href="https://github.com/drizzle-team/drizzle-orm/discussions/1339">feature request</a>)</li></ul><p>I usually detest code generated by GPTs. As a rule, they produce the average mediocre result of everything out there. But the results I got for a simple prompt were quite tolerable:</p><ul><li>knex with ts-node: <a href="https://chatgpt.com/share/6890bf40-187c-8011-9ace-1ed9ad27fa0a">ChatGPT — Node.js knex.js TypeScript setup</a></li><li>sequelize with ts-node: <a href="https://chatgpt.com/share/6890aa70-827c-8011-a049-c599af0ca1a4">ChatGPT - Node.js Sequelize TypeScript setup</a></li></ul><p>You can use yourselves similar prompts for the other options…</p><h3>Pro Tip: Closing a gap with an existing database</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*I1JxupJChAT-hHm2" /><figcaption>Generational gap</figcaption></figure><p>When I meet a customer that need help with DB migrations — they have already started their project. But they are yet to adopt a procedure that will safeguard their DB migrations. What I described so far regards a new project. Here is how to bridge the gap with an existing one.</p><p>The challenge is to get a situation where after the 1st migration, the DB migrations project and the DB are in sync. I.e. — the DB migrations project is caught up with everything that was done on the DB until now. After this migration — we’re back on the track set by the best practices following the manifest described above.</p><p>This means that the first migration should describe the state of the DB when the tool was introduced. Applying it will end with the current state of the DB and downing it leaves a clean empty DB.</p><p>However — ℹ️in principal, migrations should not be idempotent.<br>On the contrary — the migrations are expected to be declarative and deprived of logic. I.e.: They assume a <strong><em>known previous state</em></strong>, and as a result the code is very simple.<br>You want to stop when they do not meet the state they assume — it implies <strong>drift = changes you’re not aware of</strong>. Such changes imply a risk that should be mitigated by checking them and bringing them under control.</p><p>Therefore, applying a first migration on an existing DB require a special-case handling.</p><p>Few ways to do that:</p><ul><li><strong>Way 1 — onboard the DB to the tool</strong><br>This is done by with one last “old-school” SQL migration.<br>This old-school migration creates the migrations table with a record representing the first migration in the project already in <strong><em>applied </em></strong>state. This makes sure the tool won’t run it on existing onboarded DBs, but it would still run on fresh new DBs. It will also still run any new migrations on any DB.<br>After that — all migrations on all target DBs are expected to be managed by the DB migrations project.</li><li><strong>Way 2 — idempotent first migration.</strong><br>Here we make an exception of the 1st migration, so that it will cover both cases: creating a DB from scratch, AND apply 1st time on an existing production DB. <br>The result could be long not so declarative, and therefore “ugly”:<br><strong>It must be communicated that the 1st migration is not a good example to follow!</strong></li><li><strong>Way 3 — migrate to a new DB</strong><br>This way creates the tables in a new DB with the tool and migrate the data there. <br>It creates a full control over the new DB with no tricks whatsoevever. This way implies a risk:<br>The biggest temptation in this way is to try to fix all kinds of small things on the way. <br>This will have implications on the Data Migration, on the ability to provide the new DB to existing services, and more. All that makes managing the rollout manual and risky, and could require a down time.</li></ul><h3>Conclusion</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*TL1TSpDu2uvJV_Vk" /></figure><p>Its been over 55 years since relational DBs have hit the market. Along with the rest of the rollouts types — DB Migrations become more and more reliable and mature:</p><p>Now is the age of IaC and GitOps. Now, it is easy to master a practice and a workflow that manage them consistently and reliably . One that revolves around a DB Migration projects, where each commit is a snapshot in a ledger.</p><p>It is also possible to onboard an existing database to the workflow and the practice. To enjoy the confidence and the serenity they bring.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/698/0*Pc3ZhyoOas_nBtZx.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ad06ea5944f7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/israeli-tech-radar/controlling-migrations-of-dbs-ad06ea5944f7">Controlling Migrations — of DBs</a> was originally published in <a href="https://medium.com/israeli-tech-radar">Israeli Tech Radar</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Woodstock in AWS-Summit Tel-Aviv 2025]]></title>
            <link>https://osherel.medium.com/ai-woodstock-in-aws-summit-tel-aviv-2025-7c62991ec95a?source=rss-90db3ed60cfe------2</link>
            <guid isPermaLink="false">https://medium.com/p/7c62991ec95a</guid>
            <category><![CDATA[community]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[culture]]></category>
            <category><![CDATA[tel-aviv]]></category>
            <dc:creator><![CDATA[Osher El-Netanany]]></dc:creator>
            <pubDate>Fri, 30 May 2025 09:48:49 GMT</pubDate>
            <atom:updated>2025-06-20T07:51:54.117Z</atom:updated>
            <content:encoded><![CDATA[<p>Red was standing on stage disoriented, harkening to the murmuring hubbub in the crowd, his purple hair moving lightly in the wind. He was nervous. He is not at home. He took a deep breath, opened his eyes and looked around. Then he said: <strong><em>Hey, Poncho, look! it’s like Woodstock, but for nerds!</em></strong> The crowd cheered flattered. From that moment he started to relax, and the show rolled on.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/873/1*akQUt-HWSCuVIpk60Ic87A.png" /><figcaption>Red. Made one more comeback. (shot from my phone)</figcaption></figure><p>This is not my usual content. Actually, I already am in a state where for the past year I have had no usual content (you have to have <strong><em>some </em></strong>content to have a <strong><em>usual </em></strong>content). <br>But the changes the AI wave brings with it brought me to a writing crisis. Suddenly, everything seemed so pointless. Knowledge and experience are not built in effort. They are manufactured. Thoughts are not wrought, they are generated. So what will make mine worth reading?</p><p>In the shadow of the AI wave, I have to share what I have that AI does not: <strong>My humanity. </strong>For a long time I considered it private. My own. But I have to adjust or fade out.</p><p>So no, this is not a deep, well-thought, every-word-considered post like I loved my content to be. This is a short post of my human impressions gathered at the Tel-Aviv AWS-Summit 2025, roughly put and rushed to the screen to stay relevant.</p><p>Hopefully, it will prove to be <strong><em>NOT </em></strong>pointless, and help unclog my writing barrier.</p><h3>Summit Highlights (sort of TL;DR)</h3><p>Here are my big takeaways:</p><ol><li>The main star: AI <br>- AWS Bedrock — the cloud services for working with AI Models<br>- AWS Q for developers — a companion agent.</li><li>The Community is growing. <br>- This has immense implications.</li><li>Big jump, and still the production of the event has key points to improve.</li></ol><p>The AI wave is flooding everything. <br>As I stand in the main exhibition hall and listen to the buzz around — I could not ignore hearing the word “AI” said by somebody somewhere every few seconds.</p><h3>Onboarding needs improvements</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*coWUDHA6buCsVYk6ElqlXw.png" /><figcaption>my badge on my desk the day after</figcaption></figure><p>In my experience, the entrance procedures did not work. I spent 40 mins in queue and missed the breakfast and keynotes. Perhaps I was waiting in the wrong line, or perhaps there was a big group of people that came together and were using the check-in stations to register and not just to check-in. That was very bad.</p><p>The venue itself was huge. Pavilions were set across the entire expo, and the movement between them takes long minutes. This makes the hopping between sessions less flexible, as you are limited to sessions in more or less the same building, or bound for a walk.</p><p>The<strong><em> AWS events</em></strong> application was working very slowly. Given the expansion of the used venue surface —the navigation part of it became more necessary, but did not work well.</p><p>I don’t know how much of it showcases a problem with AWS services. Opening the app the first time since the last summit — it needed an update. It took almost 30 minutes to download the update. That is an indication that the physical cells of the cellular network were absolutely crowded, so... take it with a grain of salt.</p><p>It took me quite a long time to get oriented and reverse-engineer the topography design decisions of the content curators. That was very alienating. Still, I could find maps and helpful signs scattered in the venue to help with navigation.</p><h3>The offered activities</h3><ul><li>There was a huge main exhibition hall with a myriad of booths full of information and swag.</li><li>There were 2 main session pavilions with multiple halls in almost every room available.</li><li>There was an interactive Gen-AI area with multiple booths showcasing services and architecture.</li><li>All of the smaller satellite buildings in the venue were also in use.<br>There is still a growth potential, but at this pace — not for long.</li><li>The outside area was turned to a huge shaded lounge with multiple bars and sitting places.</li><li>Food, drinks and refreshments were offered in a wider range of hours compared to previous events. Sadly, I saw only one more person besides me who brought non-disposable dishes with them.</li><li>It ended with the Redband Rock Concert, hosting Ninet Tayeb, Berry Sakharof, and Full Trunk.</li></ul><h3>Content</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C9Pj7z3SgshqJgqtpaiI2A.png" /><figcaption>(img from <a href="https://lynx.co/success_story/aws-summit/">here</a>)</figcaption></figure><p>It was very evident how much the AI services dominate the curriculum.</p><p>Kubernetes, Serverless and big data were all still there — but mostly as taken-for-granted building blocks we already celebrated. More in the background as AI is taking the front line.</p><p>So I got the vibe and decided to orient myself around the AI content track.</p><h3>The AWS AI suite</h3><p>This did not start this year. It has been going on for years.</p><h4>The new stars</h4><ul><li><strong>Bedrock</strong> — a suite of services to consume services from AI models, oriented towards building AI agents and workflows.<br>Consist of<br> - LLM &amp; FM Service aggregator<br> - Guardrails functionality — filter before sending content to LLM and before showing a result to the user<br> - visual playground (in the console)<br> - RAG utilities with multiple in-depth optimization options</li><li><strong>Q </strong>— an agent with CLI and IDE extension flavors<br>It was talked over and demonstrated and showcased all over the place:<br>- how it explores and summarizes a codebase<br>- how it generates diagrams<br>- how it proposes code changes<br>- how it can transform old code to a modern code, helping to close tech-debt.</li></ul><h4>The old stars</h4><p>And there were the AI old timers, which are only a few years old:</p><ul><li>Sage maker — a suite of services to train AI models</li><li>Lex — the predecessor and enabler of the GPTs — a set of services for analyzing text.</li></ul><h4>Hot Lectures on the AI topic</h4><ul><li>A deep dive into prompt engineering</li><li>Working with the Q AI agent</li><li>Coding an agent</li><li>Streamlining workflows with agents</li><li>Training RAG models</li></ul><p>Each talk came with an industry showcase.</p><p>Sure, none of these talks make participants educated experts. But they do give an overview of the subject in a manner of:</p><ul><li>what’s going on there</li><li>what are the capabilities</li><li>what are the basic building blocks<br>- and -</li><li>where the industry is heading to.</li></ul><h3>Community</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*etBa_GRRHWVg4bTL.jpg" /><figcaption>(img from <a href="https://lynx.co/success_story/aws-summit/">here</a>)</figcaption></figure><p>The investment in the community was notable. It’s inevitable as the event turned from a warm familiar geek community event to a local AWS festival that culminates with a Rock concert.<br>A concert of the ever-comeback-band: Redband. They were comforting and countering the immense change.</p><p>The growth is unimaginable. But the change in size brings a change in the population.</p><h4>The Age of Age Differences</h4><p>For a start — the age range is pushed to the extreme. I could see a mother dragging a baby cart between the session rooms. I could see parents introducing their children to cloud ideas and to this type of activity. Also — gray hair is not rare, but in the mainstream. I could see older seniors with years of experience and/or a burning curiosity.</p><h4>Inclusivity has two sides</h4><p>Second — The variety grows: you see more representatives from the Arab and Jewish Orthodox sectors. The number of participating women has also grown significantly — and both changes are <strong><em>a very good thing </em></strong>as a bigger part of the population can tap into this economic miracle, do well for themselves and contribute to society.</p><p>However, it does bring some undesired effects. I got to hear some remarks that I wish were never said. Comments that should have no place in an inclusive community. However, being the absorbent person that I am, I did overhear them and I have to spit it out of my mind.</p><p>I cannot justify it, but I can see why it comes. The bigger the crowd and the more varieties there are in the crowd — the higher the chance to meet a “trigger”. From all levels.</p><p>Here’s just the surface: a person who chooses to dress in a way that, according to your code, is too different, too much, or with all the respect — too little.</p><p>Unfortunately, in such polarizing days, people are becoming more practiced in responding to triggers in emotionally alienating ways than in handling them respectfully.</p><p>On the other hand, it’s easy to blame only the beholder. A person should give a thorough thought if the way they dress attracts the kind of attention they want in such an environment. <br>In extreme cases, one’s background does not leave them a choice. But most of us are privileged to have one. Take it wisely.</p><p>And that’s just the surface. There’s still a lot more work.</p><h4>The together lonely syndrome</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/901/1*KkQLHRWrnIQLbI_wrzszDw.png" /><figcaption>where am I? (img from <a href="https://lynx.co/success_story/aws-summit/">here</a>)</figcaption></figure><p>The shaded lounge is buzzing; a thousand people gathered under one roof driven by shared passions. I sail across the crowd towards the popsicles refreshments place. Where am I? In previous conventions I was sailing across a sea of spontaneous, serendipitous connections — the heart of what makes a community feel <em>alive. </em>But now <em>— </em>I hardly see it anymore. The size is intimidating. There were many mingling and sitting places, however, most are sitting with the friends they came with or knew before, and most conversations are private. Those who don’t participate— sink into their phones.</p><p>The feeling of a warm, welcoming nerd community is long gone.</p><p>It’s hard to feel you’re safe in a community of friends and develop a sense of belonging when the number and variety of people you see around you is that big. The human psyche is just not built for it.</p><h4>A member of the herd</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9VaOTf4yDNgbxFexYPzi4A.png" /><figcaption>Kadishman’s sheep, famous for their human eyes (img from <a href="https://www.mutualart.com/Artwork/Herd/979C6FFE88000FA4EFF423A55EAAF515">here</a>)</figcaption></figure><p>In previous summits we heard how servers should not be snowflakes, but members in a herd. Ephemeral, replaceable, resilient through numbers. Git-Ops was the wave, not too long ago.</p><p>Now we, the humans, are becoming the herd.</p><p>As AI agents lower the entry bar — more of us fit in. We, too, are expected to adjust for scale, to become interchangeable, to plug into the hive and be more “useful” when we all act the same, sound the same, produce the same, telling AI what to say for us in its politically correct, polished voice.</p><p>The wave is already all over me. But I want to make sure that my son will still have a place to be both himself and a vibrant part of a great thing.</p><h3>Conclusion</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xYmGvDDuVRhY9URqv4kgqg.png" /></figure><p>I have no conclusion to make. I am still digesting. This AI wave fills me with a mix of wonder and disgust.</p><p>Donno. Many reasons. It does lower the entry level bar, but makes specialization much harder. <br>Making technology so accessible also removes the charm of being a techie. <br>The intensity brings fatigue before it even begins.</p><p>But, the peak is that it pushes us away from thinking and more towards animalistic, impulsive behavior masquerading as witty, sharp instincts. But that’s content for another post that I hope I’ll ever get to finish by myself, before breaking down and letting some agent do it for me.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7c62991ec95a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What’s your professional experience?]]></title>
            <link>https://medium.com/israeli-tech-radar/whats-your-professional-experience-e72c61bd18b3?source=rss-90db3ed60cfe------2</link>
            <guid isPermaLink="false">https://medium.com/p/e72c61bd18b3</guid>
            <category><![CDATA[culture]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[recruiting]]></category>
            <category><![CDATA[job-hunting]]></category>
            <dc:creator><![CDATA[Osher El-Netanany]]></dc:creator>
            <pubDate>Mon, 28 Oct 2024 07:34:14 GMT</pubDate>
            <atom:updated>2024-10-29T10:05:25.039Z</atom:updated>
            <content:encoded><![CDATA[<h4>I’m a technical coding consultant who changes environments a lot. Here are some lessons I learned.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*GEmZqgNCoMwE8stv.jpg" /><figcaption>Moving Forward (image from <a href="https://www.skillcast.com/blog/how-to-be-professional-at-work">here</a>)</figcaption></figure><p>As a technical person, it’s easy to fall into a pattern where a job interview makes you spit robotically some pitch about your technical skills and past. <br>It is true, that an interviewer needs to be convinced that you’re technically capable, but that is hardly half of the story.</p><p>There’s more to this than meets the eye. And in two different ways.</p><p>First — as technical people, we are indeed technical. But we are people first.<br>Second, the interview is a chance for you to meet them and their environment as well as it is a chance for them to meet you.</p><h3>A blind spot of the English language</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/970/0*ASo14CxZpMcl8BC5" /><figcaption>The point of view of a language (image from <a href="https://setu.in/blogs/listing/reasons-for-blind-spot-in-eyes">here</a>)</figcaption></figure><p>As a non-native English speaker, I came to find a blind spot in the English language. English uses the word ‘experience’ to describe very different things.</p><p>See how many variants google-translate proposes when trying to translate experience to other languages:<br><a href="https://translate.google.com/?sl=en&amp;tl=fr&amp;text=experience&amp;op=translate">French (10)</a>, <a href="https://translate.google.com/?sl=en&amp;tl=de&amp;text=experience&amp;op=translate">German (8)</a>, <a href="https://translate.google.com/?sl=en&amp;tl=uk&amp;text=experience&amp;op=translate">Ukrainian (13)</a>, <a href="https://translate.google.com/?sl=en&amp;tl=ar&amp;text=experience&amp;op=translate">Arabic (10)</a>, <a href="https://translate.google.com/?sl=en&amp;tl=zh-CN&amp;text=experience&amp;op=translate">Chinese (15)</a>, <a href="https://translate.google.com/?sl=en&amp;tl=ru&amp;text=experience&amp;op=translate">Russian (18)</a>, <a href="https://translate.google.com/?sl=en&amp;tl=hi&amp;text=experience&amp;op=translate">Hindu (11)</a>, <a href="https://translate.google.com/?sl=en&amp;tl=ja&amp;text=experience&amp;op=translate">Japanese (9)</a> and so on…</p><blockquote>BTW, <a href="https://translate.google.com/?sl=en&amp;tl=da&amp;text=experience&amp;op=translate">Danish (1)</a> and <a href="https://translate.google.com/?sl=en&amp;tl=no&amp;text=experience&amp;op=translate">Norwegian (1)</a> seem to have the same blind spot…</blockquote><blockquote>The problem with that is that one of the meanings becomes dominant, and overshadows the others, creating the blindspot.</blockquote><h3>Two Meanings</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/849/1*vDAg9vkLXjChjwVyqZFE-g.png" /><figcaption>Depend on what you call a face (image from <a href="https://www.etsy.com/no-en/listing/1340428655/face-with-raised-eyebrow-emoji-pillow">here</a>)</figcaption></figure><p>The two meanings I’m interested in to make my point are:</p><ul><li>to be experienced in a skill or a practice</li><li>to have an experience of something*.</li></ul><blockquote>*) This is a partial cover of this meaning. The closest English way I could find is <strong>to have the impression of</strong>, which does not fully overlap. <br>I hope it’s enough to drive the point home…</blockquote><p>Of the two meanings above, I feel the first meaning is well understood. However, the second meaning packs a lot.</p><p>An interviewer is interested in what you bring with you on top of the technical skills. What practices do you bring with you? What‘s in you that can reinforce the team culture? What morals, conduct, and temper? What empowering impressions are stored in you that you can share? <br>- All these fall under the second meaning.</p><p>Let’s break down that latter meaning.</p><h4>Experience of a good practice</h4><p>Good practices of the trade border with technical skills, but go far beyond.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V5o8wneaLJBrHY5GvmglBw.png" /><figcaption><a href="https://medium.com/israeli-tech-radar/do-your-tests-communicate-a0f7a3e99a00">Beyond the basics</a> (image from <a href="https://medium.com/israeli-tech-radar/do-your-tests-communicate-a0f7a3e99a00">here</a>)</figcaption></figure><p>Practices like:</p><ul><li>providing code with guarantees — <a href="https://medium.com/@osherel/functional-tests-how-low-should-it-get-459c56014c37">automated tests (link)</a>, benchmarks, UI tests</li><li>providing clear and documented code</li><li>proofing software in automated CI — <a href="https://medium.com/israeli-tech-radar/do-you-waterproof-your-software-e9ba250bd8bd">waterproofing software (link)</a></li><li>facilitating rollout using <a href="https://medium.com/israeli-tech-radar/whats-exactly-ci-cd-8e943902f38e">CD (link)</a></li><li>protecting <a href="https://medium.com/israeli-tech-radar/what-are-software-concerns-and-why-keep-them-separate-741c7491b7d9">architectural boundaries (link)</a></li><li>DRYing the code</li><li><a href="https://www.oreilly.com/library/view/tidy-first/9781098151232/">Tidy first (link)</a></li></ul><p>All of them come with a deterring cost.</p><p>However, a person with a vivid experience of such good practices does not need to be convinced of them. Moreover, they can be their advocate, guiding the team to a safer and proven path.</p><h4>Experience of a healthy work culture</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2iLI0Zo8mvgT_kG47UheAg.png" /><figcaption>Presense. Meeting together is being together (image from <a href="https://online.champlain.edu/blog/how-to-lead-effective-team-meeting">here</a>)</figcaption></figure><p>More than with best practices, a dev-culture is the product of all of the members of a team. Bringing experience of good culture helps build and/or reinforce better dev culture.</p><p>This circle is wide. It builds over the level of the practices, and includes social aspects like:</p><ul><li><strong>Maintaining Collaborative Concentration and Focus </strong><br>For example, with a <a href="https://medium.com/israeli-tech-radar/professional-daily-gives-your-team-a-nudge-4edb0fb73b3b">good daily (link)</a></li><li><strong>Continuous Improvement </strong><br>For example, with <a href="https://www.funretrospectives.com/">fun retrospectives (link)</a>.</li><li><strong>Delivery and Acceptance Culture </strong><br>For example, with demos, personal handoffs, and documentation.</li><li><strong>Encouraging collaborative communication </strong><br>For example by preferring direct communication vs following a ping-pong over asynchronous texts.</li></ul><h4>Experience of a Productive Work Environment</h4><p>Environment is a big word.</p><blockquote>A technical definition for an environment: the preconditions and overall structure in which a process, a computer, or a person operates.</blockquote><p>Let’s apply this definition to the human world.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uganjPHuY5FQW3KllFm72g.png" /><figcaption>Open space, closed communication (image from <a href="https://hughesmarino.com/san-diego/blog/2019/05/15/8-solutions-to-open-office-issues/">here</a>)</figcaption></figure><p>Consider a person who has experienced a productive work environment that was empowering to them. This person is far more likely to recognize the preconditions that will safeguard their productivity in a new environment— or their absence.</p><p>Whenever I try to describe these preconditions, the word that comes to my mind is Hygiene.</p><blockquote>While ‘Hygiene’ is technically about preventing disease, in my context, it is a metaphor. A metaphor in which I’d rather focus on the hygiene side instead of on the disease.</blockquote><ul><li><strong>Space hygiene</strong> — when you enter the workspace, how much clutter do you see? Does it inspire order, predictability, and reliability?</li><li><strong>Sound hygiene </strong>— This <a href="https://youtu.be/y5nbWUOc9tY?t=499">TED talk (link)</a> says it best. <br>In short: What is the level of the background noise? When you want to listen to someone talking to you, how easy is it? Do you need to raise your voice to be heard back?</li><li><strong>Intimacy hygiene </strong>— when you need to have a private talk, are there enough spaces for it?</li><li><strong>Focus Hygiene </strong>— when you need some “in-the-zone” time, how easy is it to enter? How easy is it to sustain?</li></ul><h4>Experience of an inspiring Role-Model</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KWjJgj5GdoVwvvS9.jpg" /><figcaption>Role models. For good or evil… (image from <a href="https://screenrant.com/incredible-behind-scenes-facts-sergio-leone-good-bad-ugly-western-clint-eastwood/">here</a>)</figcaption></figure><p>A role-model experience requires more than the 120 minutes we get in the cinema. In many cases, regardless of how well-wrought a character is, what we see in the cinema stays there locked in another world. <br>However, an experience of a role model that is made in the minutes and seconds of your every day is far more transcending.</p><p>We are used to looking at role models as central dominant figures. As leaders in the center of attention. But not everyone has to be the leader. Many people are content with doing their part as peers. It does not mean they cannot inspire as role models, or be inspired by people they take as role models.</p><p>Some role models are a good example. Others are an example of what not to be. The person to inspire you could be your peer, your subordinate, your manager, or that person from another department that you meet in the kitchen every now and then for a coffee and a story. <br>Make sure you do not miss a lesson from any of them.</p><p>From an interviewer’s perspective — at this point, it is not about you. <br>Here, the interviewer is interested in how your peers appear in what you say. It goes beyond the “Are you a team member” question. <br>It gets to: Are you inspired? Are the peers you worked with a point of strength or a burden? Did you share knowledge? Did you have from who to learn? How did you use that to develop yourself?</p><h3>Meaningful Experience</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/622/1*TQnf8KUZhZDS-FQsv7vRYg.png" /><figcaption>Examined in layers (image from <a href="https://hr.economictimes.indiatimes.com/news/trends/tiktok-isation-of-recruitment-are-videos-here-to-stay/87216074">here</a>)</figcaption></figure><p>I touched on the following aspects of experience:</p><ul><li>Best practices</li><li>Healthy development culture</li><li>Productive environment</li><li>Inspiring role model</li></ul><p>To use them as building blocks, we have to discuss some implications.</p><h4>Roadmap for Continuous Improvement</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*c1tSdcP4Z5pIh0Aq.png" /><figcaption>Got a roadmap? (image from <a href="https://www.tikalk.com/career/">here</a>)</figcaption></figure><p>In such ever-changing environments, those who thrive are those who commit themselves to a <a href="https://medium.com/israeli-tech-radar/keeping-relevance-in-a-world-of-constant-change-7ec074ff8236">continuous self-development loop (link)</a>. Those who keep their feet on the ground, their fingers on the keyboard, and some attention on a higher oversight.</p><p>However, consider a skill learned and not used. Is it really obtained?</p><h4>The Bicycle Fallacy</h4><p>Riding a bicycle is something one does by oneself. <br>There’s nothing except the person, their bicycle, and physics.</p><p>What makes riding a bicycle unforgettable is the <strong><em>consistency </em></strong>of the experience. The experience of riding a bicycle will serve you whenever you’re approaching a normal bicycle under the same rules of physics.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FMFzDaBzBlL0%3Fstart%3D1%26feature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DMFzDaBzBlL0&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FMFzDaBzBlL0%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/edef346451c97b78f6083b138866718b/href">https://medium.com/media/edef346451c97b78f6083b138866718b/href</a></iframe><p>It’s common to compare learning by experience to riding a bicycle. The claim is that once you get it — you always will. <br><strong><em>However, this is a fallacy</em></strong>. Given the plasticity of the human brain and how it evolves — best practices and development culture adhere more to the use-it-or-lose-it rule. What is granted for bicycle physics is not granted for this experience.</p><p>Technology change. Practices change. Environments change. Teams change. Individuals change. Many a person is no longer who they were not long ago.</p><blockquote>The balance of developing a work culture needs to be maintained continuously.</blockquote><h4>Express yourself</h4><p>So, you’re at a job interview.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ncXMQxDKNF5uqBAk" /><figcaption>Find what’s inside you that they need to hear (image from <a href="https://www.linkedin.com/pulse/flipping-interview-21-powerful-questions-help-you-earn-sean-tien/">here</a>)</figcaption></figure><p>If the interview is physical — have a look around. Pay attention to how you feel.</p><p>Pay attention to the subtext that implies what the employer needs. Find the parts in you that will make the sell.</p><p>Be more than a name — be a person. When the interviewer is making a conversation — tell about an inspiring coworker, and what you learned from them. Wish to find such people in the new place, and see what the interviewer has to say. <br>Tell about a practice that strikes you as engaging, or productive, and wish to find equivalents in the new place. See if they are inspired and will share back.</p><p>If you made it to the final stage and all interviews were online — ask if you could see the office in person before you sign.</p><h4>The Road Not Taken</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*uVlGxv29IutHYw2qm4vrJw.png" /><figcaption>Which is the right way, the left or the right one? (image from <a href="https://owlcation.com/humanities/Analysis-of-Poem-The-Road-Not-Taken-by-Robert-Frost">here</a>)</figcaption></figure><p>One can claim that the only control we have over the work environment and the peers we get is ours only while considering offers. While I can argue that impact is made continuously, I admit that the impact of these moments of choice is far more critical.</p><p>Here’s something I wish I knew when I was younger:</p><blockquote>The choice you make in your current job search is a big part of the success in your next search.</blockquote><h4>Editing the DNA</h4><p>It’s easy to narrow the perspective to that of the individual.</p><p>If you put yourself in employers’ shoes, you’ll discover one more important aspect.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/894/1*YqjbluizfcxjcEqQdPsz0g.png" /><figcaption>Like chosing genes, but with people (generated using Dall-E).</figcaption></figure><p>In building a team, employers aspire to select the people who come with the right experience, in <strong><em>all</em></strong> meanings.</p><p>But, the <a href="https://medium.com/israeli-tech-radar/i-take-full-responsibility-7fd9547ca6dd">recruitment and layoff pendulum</a> forever moves between a market of employers and a market of employees. <br>The smaller the pool of available talent is, the more prone recruiters are to compromise and just work with what they’ve got. This means there are always likely to be people who are harmful to the work experience.</p><p>The team-building art then shifts from how to sort them out, to how to absorb them into a healthy culture and leave them imprinted with good experience.</p><blockquote>However, many teams do not have the means or the know-how to do that. Especially among the small, the young, and the rapidly growing.</blockquote><h4>Protecting your Experience Hygiene</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*YXHuV9OGcY4KyNeF.jpg" /><figcaption>A moment of honesty. (image from <a href="https://www.sciencealert.com/why-hard-keep-eye-contact-conversation-science-overload">here</a>)</figcaption></figure><p>Honestly, it’s hard to find a place that will tick all the boxes: practices, culture, environment, and team. <br>And that’s on top of the usual logistics and economics — one that pays well, is stable, and is easy to commute to and from.</p><p>But ticking most checkboxes is the wrong way to look at it. Every such aspect is a measure that ticks green above some threshold. However, below some other threshold — they <strong><em>incur damage</em></strong>.</p><blockquote>When you get to a bad place — don’t stay there.</blockquote><p>This is easier said than done. However, after the day and a half I spent in the industry, I say it is a matter of hygiene. <br>People who know how to protect the hygiene of their experience bring with them a more precious experience than those who don’t.</p><h3>Conclusion</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a3eB4KhNUiM0kOgwIKwcuA.png" /><figcaption>You’re hired. (image from <a href="https://finders.ch/en/2021/06/09/the-handshake-might-be-a-thing-of-the-past-but-hiring-still-needs-the-human-touch-2/">here</a>)</figcaption></figure><p>As technical personnel, we try to widen our perspective when we look at technical aspects of our profession. But we tend to neglect the human perspective. We are technical people, but first, we are people.</p><p>By understanding the other meanings of experience, we should know to protect them, nourish them, and project them in interviews. By acknowledging our needs, we should know to accept offers that provide the conditions under which we can obtain a good experience.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e72c61bd18b3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/israeli-tech-radar/whats-your-professional-experience-e72c61bd18b3">What’s your professional experience?</a> was originally published in <a href="https://medium.com/israeli-tech-radar">Israeli Tech Radar</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A lab of CJS require and ESM import]]></title>
            <link>https://medium.com/israeli-tech-radar/cjs-require-and-esm-import-e2a6316a161d?source=rss-90db3ed60cfe------2</link>
            <guid isPermaLink="false">https://medium.com/p/e2a6316a161d</guid>
            <category><![CDATA[modules]]></category>
            <category><![CDATA[full-stack]]></category>
            <category><![CDATA[commonjs]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Osher El-Netanany]]></dc:creator>
            <pubDate>Thu, 05 Sep 2024 14:58:38 GMT</pubDate>
            <atom:updated>2024-09-09T14:46:46.164Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<p>ESM was officially stable in 2019. After 5 years — this is a good time for a checkup.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_YIK9XO7bleguzmj-D9Mpg.png" /><figcaption>A generation gap (Image from <a href="https://www.aetv.com/shows/wwe-rivals/season-4/episode-6">here</a>)</figcaption></figure><p>This is not a “<em>hate-it-or-love-it</em>” situation like TS is. It does not end at transpile time with minor leaks into the runtime envelope — it IS the runtime envelope. And one is not purely a superset of the other.<br>It is a different model that has meaningful runtime ramifications.</p><p>Now, after 5 years in the market, it&#39;s time to have a deeper look, do some analysis, and perhaps make some predictions.</p><h3>Disclaimers</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/729/1*XSGXoIJhpLBjHTW7RGnY5w.png" /><figcaption>(img from <a href="https://www.catersource.com/business-operations/you-said-it-without-saying-it">here</a>)</figcaption></figure><p><strong>This is a technical post.</strong> For all my less technical readers — you will have to excuse me for this one. There will be some low-level grit here.</p><blockquote>There are other less gritty goodies at different stages of work, so stay tuned.</blockquote><p><strong>Code-snippets included</strong>. I arranged all code snippets in screen captures, so if you’re listening to the article on a walk or a drive — the screen reader will not drive you crazy lumping over code expressions it cannot pronounce.</p><blockquote>I include the snippets in “copyable” format extracted from my zsh-history <a href="https://gist.github.com/osher/d14ad060a6da1e08608aa463f9bbd7f8">in this gist (link)</a>.</blockquote><h3>Apples and Oranges</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/660/0*9-wV7Zq54knSi_6C" /><figcaption>Well, both are fruites…. (img from <a href="https://clevertap.com/blog/how-to-compare-apples-and-oranges-part-i/">here</a>)</figcaption></figure><p>Apples and Oranges are both farmed cultivated fruits. Both are juicy. Both are sweet with a sour tendency. Both are packed with vitamins. And their blossom — ah!! And both ‘made the cut’ into that phrase about unfair comparisons…</p><ul><li>require — the facilitator of module reuse of the <strong>CommonJS</strong>.</li><li>import — the facilitator of module reuse of <strong>ES Modules</strong>.</li></ul><p>This mandates that they do have a wide base in common. However, they are quite different.</p><p>Coming from the simplicity of CJS, ESM seems over-architected, with its’ default, named fields binding, import *, and a sore different and limited destructure syntax.<br>But in return, it’s more expressive, and safer.</p><p>The latter may turn the ballot. Let’s explore.</p><h4>CJS require</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LJUhL93BkmGFO_0d8jmRkg.png" /><figcaption>Require. the renegade lightsaber of the old ways… (image from <a href="https://danspratling.dev/blog/javascript-is-import-or-require-better">here</a>)</figcaption></figure><p>In Common-JS, require is a <strong>blocking synchronous runtime function calls</strong>. Like an overpowered recursive version of fs.readFileSync.</p><p>Whenever a CJS code encounters require it halts everything until the required module has been loaded and evaluated and its exported value can be returned.</p><p>When the module was not already called before — the result is a blocking operation that stops everything until it’s complete.</p><p>First, CJS <a href="https://nodejs.org/dist/latest-v14.x/docs/api/modules.html#modules_all_together">resolves the file or directory</a> from which the module can be loaded. Then, once loaded — it evaluates. <br>If the evaluation encounters more calls to require — the process repeats in a deeper stack, where all calls to require are performed this way <strong><em>in runtime</em></strong>, blocking, one at a time, and in the <strong><em>deterministic </em></strong>order they are met. <br>I.e. — If a module gave any runtime code before the require was called — it was executed before the require.</p><p>The following screenshot shows it’s an operation that on my WSL takes 3~4 ms</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/929/1*bPbDlWdRSffprJ3lXzUdvw.png" /><figcaption>Just a simple way to probe</figcaption></figure><p>Let&#39;s do that in big numbers: In the next screenshot, I created 500 modules that form a linear dependency graph of depth 500.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*47YGdauJ69u8_sOu2pFiVw.png" /></figure><p>Loading them took around 40ms.</p><p>Here are the results if I break the chain at 250 depth and 100 depth:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h71gcBMbxA4y5ITV2n4Png.png" /></figure><ul><li>500 depth: ~40ms</li><li>250 depth: ~28ms</li><li>100 depth: ~16ms</li></ul><p>Mind that my generated modules do not do anything except require each other. Thus, the measures reflect mostly the time it takes to resolve the files and access them.</p><p>Real-life modules will take more effort to read, parse, and evaluate. However, that will happen in both CJS and ESM.</p><h4>ESM import</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/837/1*4qiuQ1NQDvv3-IgS9-xkGQ.png" /><figcaption>Import. Imperial bureaucracy (image from <a href="https://stackoverflow.com/questions/55997921/how-do-i-change-these-require-statements-for-these-modules-to-use-import-stateme">here</a>)</figcaption></figure><p>In ESM, import are <strong>precompile directives</strong>.<strong> </strong>They are handled in <strong>dedicated stages in the lifecycle</strong> of the evaluation of modules. A file may import as many modules as it needs, and they are all being resolved <strong><em>in parallel</em></strong>. The runtime phase of the module evaluation happens when all of the modules it imports have been resolved, loaded, and evaluated — so it can run with all its dependencies ready.</p><ul><li>Like any other user code in the V8 — once read, they are evaluated <strong>one at a time</strong>.</li></ul><p>Under the hood, the mechanism uses an asynchronous code that does not get to claim control over the main loop as long as it’s waiting for its imported dependencies.<br>The module cannot execute any code before all the modules it calls in such import<strong><em> directives </em></strong>have been evaluated.</p><p>A subset of this mechanism is also exposed as <strong><em>dynamic imports</em></strong> — which is what I use here in my shell to measure.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/949/1*rzeNf4i-f_A-FRyjF60Wvw.png" /></figure><p>Hmm. It measures almost twice as long as its CJS counterpart.</p><p>Let’s try to evaluate this overhead. <br>Since require loads one module at a time — let’s emulate a similar scenario.</p><p>Here’s a ridiculous experiment where 500 modules import each other, where each imports only its next, and the last imports node:fs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HvGsiymaz3C8ar1Ld8yimw.png" /></figure><p>Here are the results if I break the chain at 250 depth and 100 depth:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DrSTWrCnNaVddtdCzjEB5A.png" /></figure><p>And this is the measures summary:</p><ul><li>500 depth: ~240ms (vs ~40ms of CJS)</li><li>250 depth: ~110ms (vs ~28ms of CJS)</li><li>100 depth: ~55ms (vs ~16ms of CJS)</li></ul><p>Actually, this is the scenario that is favorable to CJS, and indeed it took the trophy hands down. <br>Let’s see the opposite scenario that should favor ESM.</p><p>In this screenshot, I modified the code in the index.mjs of each of the imported packages to export some string and import them all from the root package. This is a flat one-generation dependency graph, in which imp0 depends on the 499 others.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2wI4m7j4ZycL_NtVBzWkOg.png" /></figure><p>The results are disappointing.</p><p>~200ms. Only a 40ms improvement over the linear 500-depth graph. It is still 160ms behind CJS, which blocks the main event loop not only for evaluating modules — but also for reading them from the disk.</p><p>Here I was dispirited and did not see a point to take measures for 250 and 100…</p><h4>So. It is not about performance.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/696/0*4oTI_wTRuAKEOjgM.jpg" /><figcaption>Closing the gap (image from <a href="https://www.firstcry.com/intelli/articles/the-rabbit-and-tortoise-story-with-moral-for-children/">here</a>)</figcaption></figure><p>I have not yet met a case where these mere milliseconds of a gap in load time made a difference that will necessitate one method over another. Not in the real world of services anyway. Load balancers, scale groups, and k8s deployments are sufficient to blur any performance difference between the two. (Although it does press on my purist soul).</p><p>In the world of CLI tools, a claim might be made only when they are called so many times that these split seconds of load time accumulate into a meaningful impact. <br>In that case, they could be a service, not a CLI.</p><h3>Circular Dependency</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*XGIDwqdUWDWpLw0y.jpg" /><figcaption>Roundabout. Not that trivial (image from <a href="https://parents.stanford.edu/2017/09/05/roundabouts-may-challenge-those-new-to-campus-driving/">here</a>)</figcaption></figure><p>CJS resolves circular dependency by not interfering with the users’ decisions, offering a simple clear model, and delegating full responsibility to them under that model. <br>The quirk of the system is that it creates a module instance and adds it to the cache before it is fully evaluated. Thus, when somebody calls a module whose dependencies are not fully initiated because of a circular dependency — they will get a reference to the default exports object.</p><p>Trouble comes if the user side tries to destructure from it values that have not been initiated yet, or if the consumed module overrides it entirely by assigning a value to module.exports.</p><p>ESM comes with some safety mechanism that prevents one from accessing uninitialized fields:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/981/1*snva9CLJKiGqhfZDHtPB0Q.png" /><figcaption>trying to use an imported field before it is ready results in a ReferenceError</figcaption></figure><p>This will work if you don’t access the fields in load time, but use them only later, in runtime handlers, after they are <strong><em>eventually </em></strong>initiated.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tnByDB6QKYwUpJY0up8ZOg.png" /><figcaption>Passing the reference to the module scope is OK</figcaption></figure><h4>Mind the reverse order of initiation</h4><p>We’re importing l1 , which imports l2 , which imports l3 — which in turn imports l1 . At this stage, l3 gets a stub of l1 that will throw on access attempts that address uninitiated fields.<br>Then l3 is evaluated, after which l2 is evaluated, and l1 is evaluated last, and the import promise is resolved.</p><h3>A Showcase of a bug common in ESM</h3><p>Here’s a bug that results from a misunderstanding of the mechanism. <br>This misunderstanding is exacerbated by frameworks that premise to obfuscate the lower levels from the user.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VYv2v4GND1mVDQYlFdmDdw.png" /></figure><p>In this nest.js example, dotenv is called from @nestjs/common, while the-dto is assuming that it should be able to pick up the values that dotenv mounts on process.env. <br>However, the observed behavior was that THE_VALUE was accessed by the-dto before dotenv could run, resulting in the-dto working with an undefined.</p><p>One solution is to move the call to dotenv to a flat 1st level dependency of the main that is called first, so it will be able to run before the deeper generations.</p><p>One could also move the call to dotenv to the-dto module — but that would breach the separation of concerns principle (<a href="https://medium.com/israeli-tech-radar/what-are-software-concerns-and-why-keep-them-separate-741c7491b7d9">link)</a>. <br>Actually, accessing process.env anywhere is already a logical problem (<a href="https://medium.com/israeli-tech-radar/do-you-master-configuration-logic-b2d70948f43f">link</a>), but let’s fix one thing at a time.</p><h4>The robust solution</h4><p>I did see one more interesting solution to this. In a <a href="https://backstage.io/docs/getting-started/">Backstage app</a> project, the main entry point loads all imports dynamically and awaits each one of them— forcing a layered order between them… (the rest of the modules import each other the usual way through the head of the file).</p><h3>The elephant in the room</h3><p>ESM can import CJS, CJS cannot require ESM (<a href="https://nodejs.org/dist/latest/docs/api/modules.html#loading-ecmascript-modules-using-require">just yet</a>).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/742/0*tcp6DF_B_do975Nu.png" /><figcaption>Camouflage won’t help (image from <a href="https://tvtropes.org/pmwiki/pmwiki.php/Main/ElephantInTheLivingRoom">here</a>)</figcaption></figure><p>Considering require, the very nature of the synchronous loading dictates that if a module cannot be loaded synchronously it cannot be loaded by require. <br>On the other hand — it is legal to await a synchronous value (it’s just less performant).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*weZqeyEcFAHTHclIA51Vew.png" /></figure><p>While I can think of ways to implement synchronous loading of ESM, I’m not sure it’s a path that can be taken consistently without compromise.</p><p>When I get into the details, I see cases where the same module could behave differently if it’s required or imported, depending on race conditions between its dependencies.<br>That’s because a CJS user module can execute code before a dependency is evaluated, and ESM is forbidden to.</p><p>Another problem appears when the dual module should hold a long-term memoised state. De facto, this results in two different modules:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/658/1*-HoIs15sCOYzXI4w_b5glQ.png" /></figure><p>What’s the solution in this case?</p><ol><li>Create an ESM wrapper for a minimal CJS module that owns the state. <br>But you want to write ESM, not CJS…</li><li>So — Transpile ESM to CJS — at least for your wrapped CJS. <br>You’ll need to make sure that the rest of your ESM modules will not get the original ESM of the state module, but the transpiled one.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/763/1*GHftxM6K9k46-2qeX9O5ww.png" /></figure><p>If you let <a href="https://nodejs.org/api/cli.html#--experimental-default-typetype">automatic type-resolution work</a> — it does not have to be a package.<br>It still is a gotcha.</p><h3>Adoption</h3><p>To measure the adoption of ESM, I wrote a tiny CLI tool that takes a whiff of the node_modules and spits some statistics.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/624/1*1th2wTd4l2tFMRwfZtCJ2Q.png" /></figure><p>Then I ran it on a myriad of projects I’m actively engaged with. <br>Here are the stats of some of the open-source projects:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OTC7UQbputGC-sMixTyouQ.png" /></figure><p>Here are some comments on my results:</p><ul><li>In opensource there are packages I recently tried to learn from or PR to.</li><li>The 100-packages-test is a project where I installed the first ~60 packages I could think of.</li></ul><blockquote>I intended to go to 100, but got lazy. I allowed myself to stop after I installed about 60, took a peek, and observed over 2000 packages<em>🎁</em>...<br><em>👉</em> Packages like pg, mysql, kafkajs, rabbitmq, express, fastify, passport, nestjs, aws-sdk, vitest, config, nconf, mocha, expect, should, yaml/toml/ini/csv parsers, <strong>stream </strong>packages, <strong>logger</strong> packages, and any utility that came to my <strong><em>totally unbiased </em></strong>mind… <em>😜</em></blockquote><p><strong>The bottom lines<br></strong>The numbers do vary.</p><ul><li>CJS rules as the absolute majority</li><li>There are a lot of types projects</li><li>We do see a growing portion of dual packages</li><li>Except for vitestthat is explicitly a dedicated ESM project, the rest demonstrate a very strong Common-JS leniency. <br>Even vitest uses a big chunk of CJS modules</li></ul><blockquote>Disclaimer — the current version is naive about dual projects. <br>It counds a project as dual if it has package.json:exports. But there is one more usecase for the exports section. <br><a href="https://github.com/osher/whats-in-my-deps/"><strong>PRs</strong> </a>will be appreciated! <em>😅</em></blockquote><h4>Contribute a data point to the adoption research</h4><p>I opened a <a href="https://docs.google.com/forms/d/1ibF50XeZbcNMA2eRWdl1RdfRUGa7LcDivdOI1oG5Uv4">Google Form</a> to collect and process the data from whoever wants to contribute a data point to the research.</p><p>To produce a data point for your project — just run:</p><pre>npx whats-in-my-deps</pre><p>The useful minimum is the last Stats: part and anything that comes after, but you can send more if you like.</p><blockquote>I’d appreciate any data point you would like to contribute (or bug reports).</blockquote><p>I’ll give some months for data gathering, and if there will be anything interesting — I’ll do a recap with some graphs.</p><h3>Predictions</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/692/1*c1AZM1FsaQTgeQktfcgMRQ.png" /><figcaption>I see the future. It’s upside down?? (image from <a href="https://he.aliexpress.com/item/32886857927.html">here</a>)</figcaption></figure><p>We will see more and more packages publish themselves as ESM, but as long as there is no effective solution to this exclusivity problem — their market share excludes users of CJS that will be reluctant to relinquish the fine control they have now.</p><p>Currently, the solution is a dual support module (<a href="https://nodejs.org/api/packages.html#dual-commonjses-module-packages">link</a>), which doubles the size of packages. It is also hazardous in some cases (<a href="https://nodejs.org/api/packages.html#dual-package-hazard">link</a>).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/0*VTT4wuIr6IJl42Po" /><figcaption>I guess the same joke works with <strong><em>import</em></strong><em>… </em>(image form <a href="https://andrewzuo.com/async-await-is-the-worst-thing-to-happen-to-programming-9b8f5150ba74">here</a>)</figcaption></figure><p>Unless ESM finds a way to be called from CJS — they will stay limited to the niche of the userland, a private walled garden, or keep demanding the abhorrent special treatments of dual-support.</p><p>But.</p><p>If a good-enough solution is found that will let CJS modules require ESM modules — I predict that ESM adoption will rise even more.</p><p>All the more if the field-binding syntax will become consistent with destructuring syntax.</p><p>At the end of the day, ESM trades some performance for safety. <br>In <a href="https://www.youtube.com/watch?v=BHnMItX2hEQ&amp;t=4920s">an industry of perpetual inexperience</a> — that counts a lot.</p><h3>Afterthought — a storm in a cup of tea</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/879/1*V3jUeWgDWy7z4G1C1qUcUA.png" /><figcaption>There was a clerk who always had tea, and Pouptitz was his name (image from <a href="https://www.youtube.com/watch?v=XB1Bq8KfJGo">here</a>)</figcaption></figure><p>CJS require offers a simple deterministic model one can wrap their mind about, full control, performance, and the premise to be a dependency of any module. But it requires one to get a firm grip on the details.</p><p>ESM import trades some performance for runtime safety, abstraction, and the freedom to depend on any module.</p><p>Both mechanisms come with their gotcha moments that developers should understand if they wish to utilize them in full.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e2a6316a161d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/israeli-tech-radar/cjs-require-and-esm-import-e2a6316a161d">A lab of CJS require and ESM import</a> was originally published in <a href="https://medium.com/israeli-tech-radar">Israeli Tech Radar</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>