<?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 Nader Eloshaiker on Medium]]></title>
        <description><![CDATA[Stories by Nader Eloshaiker on Medium]]></description>
        <link>https://medium.com/@nader.eloshaiker?source=rss-7e035b520d03------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*Wo-bzPiPjv5za6AS.</url>
            <title>Stories by Nader Eloshaiker on Medium</title>
            <link>https://medium.com/@nader.eloshaiker?source=rss-7e035b520d03------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 17:27:59 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@nader.eloshaiker/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[I’ve backed agile for ten years. On my latest build, we didn’t use it.]]></title>
            <link>https://medium.com/@nader.eloshaiker/ive-backed-agile-for-ten-years-on-my-latest-build-we-didn-t-use-it-e39923866ef1?source=rss-7e035b520d03------2</link>
            <guid isPermaLink="false">https://medium.com/p/e39923866ef1</guid>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[startup]]></category>
            <dc:creator><![CDATA[Nader Eloshaiker]]></dc:creator>
            <pubDate>Wed, 18 Nov 2026 10:14:35 GMT</pubDate>
            <atom:updated>2026-11-18T10:14:35.722Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Uj-DWSEDu-JSIjt6amNcnQ.png" /></figure><p>I’ve spent the last ten years as a consultant, across 18 engagements in banking, finance, power, postal, transport and government. On most of them I was the one pushing for agile. Get the standups going, find a cadence, run the retro even when everyone’s sick of it.</p><p>So it’s a little awkward to admit that the product I’ve just shipped had almost none of that.</p><p>Since May, two developers have built Wheel Hub (<a href="https://wheelhub.io/">wheelhub.io</a>), a platform that takes train wheel measurements and turns them into something a maintenance engineer can actually use. Just the two of us. For the rail side, we spent time with an experienced industry expert, who helped us understand what an engineer actually looks for in the data. AI agents did a lot of the heavy lifting on the code.</p><p>The result is in production with live customer data, about four and a half months after the first commit.</p><p>No standups. No sprint planning. No estimation. No retros. No elaboration workshops. We had a Kanban board, and a brief that amounted to “ingest the file and show the engineer what matters”.</p><p>I’ve been thinking about why that worked, because I don’t think it was luck.</p><h4>🛠️ The ceremonies were solving problems we didn’t have</h4><p>Strip Scrum back and its ceremonies answer two problems. You’ve got seven or eight people who need to stay in step. And building software is slow and expensive, so you’d better be sure it’s the right thing before you start.</p><p>Neither was true for us. There were two of us, and with AI writing much of the code, building stopped being the expensive part. A typical ticket went from raised to released the same day. Putting story points on that would have been theatre.</p><p>I pulled some numbers from the repository out of curiosity:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_zv9CRMTNlfpegs4CJcPjw.png" /></figure><ul><li><strong>Developers:</strong> 2</li><li><strong>Time from first commit:</strong> about 4.5 months</li><li><strong>Commits:</strong> about 3,300</li><li><strong>Pull requests merged:</strong> about 2,300</li><li><strong>Tickets on the board:</strong> about 1,500</li><li><strong>Product and domain decisions on record:</strong> about 130</li><li><strong>What we built:</strong> 3 web apps, a set of serverless back-end services, infrastructure as code and an API contract</li></ul><p>We often released several times a day. Boxing that into two-week sprints would only have slowed the releases down.</p><h4>📋 We didn’t skip the discipline, though</h4><p>What surprised me, looking back, is that every ceremony’s job still got done. It just didn’t happen in a meeting.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1oMuCbaM8P3fVVHx1ytBRg.png" /></figure><ul><li><strong>Standup.</strong> The board was the status. Progress went on the ticket, and handovers between the two of us were written down.</li><li><strong>Sprint planning.</strong> Continuous. Everything carried a severity, and the worst thing on the board got done next.</li><li><strong>Elaboration.</strong> Worked out against real data: vendor manuals, real exports, published standards and our conversations with the industry expert. Each call was written down with the reasoning, about 130 so far, so a settled question never gets argued twice.</li><li><strong>Retro.</strong> Every lesson became a written rule, applied to every change from then on.</li><li><strong>Definition of done.</strong> Automated checks and a strict merge gate on every pull request.</li></ul><p>The retro is the one I’d underline. Every time something cost us real time, it became a rule. Confirm the build passed on the final version before you merge. Never let the product guess at a figure the data doesn’t support. I’ve sat through plenty of retros whose action items were never seen again. These were.</p><p>Go back to the Agile Manifesto rather than to Scrum and we were doing what it asks: working software, close collaboration, responding to change. What we ran looks far more like Kanban and continuous delivery, with some XP habits, than anything with a sprint in it. That’s still agile. It’s just not the version most organisations buy.</p><h4>🥋 Experience is what made it work</h4><p>This is the bit I underplayed when I first thought about it.</p><p>The other developer on this build is a long-time consultant too. Between us we’ve watched a lot of projects get into trouble, and it’s nearly always the same handful of ways:</p><ul><li>scope creeping a little every week</li><li>a blocker that sits there because nobody wants to raise it</li><li>a requirement the business and the developers read two different ways</li><li>the integration problem that turns up three weeks before go-live</li></ul><p>Once you’ve seen those enough times, you notice them as they start. You don’t need a retro in a fortnight to tell you. You fix it that afternoon.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PwEeg7z_MoJcDQLXyR_W3A.png" /></figure><p>Martial arts has an idea called Shu-Ha-Ri. You start by following the form to the letter, then you learn to adapt it, and eventually you put it down because it’s become how you work. In my experience most agile teams never get past the first stage. They hold the standup because the framework says so, not because they know what it’s protecting them from.</p><p>That’s really what ceremonies are: a stand-in for experience. They make sure a team asks the right questions on a schedule. If the people in the room already ask those questions without being prompted, the schedule is just overhead.</p><h4>🤖 Where the ceremonies actually went</h4><p>This is the part I find most interesting.</p><p>The AI agents writing our code are quick, but they have no experience whatsoever. Of everyone on the project, they’re the ones who genuinely need the form spelled out. So we spelled it out. Our definition of done, our severity scale, our product principles and every rule we learned the hard way are written down, and every agent reads them before it touches anything.</p><p>In a sense we didn’t drop the ceremonies at all. We took the experience they’re meant to stand in for, wrote it down once, and had it applied to every piece of work. I’m fairly sure that’s a big part of why moving this fast didn’t cost us on quality. It also means anyone who joins gets all of it on day one, rather than soaking it up over months of meetings.</p><h4>👀 What I’d still keep an eye on</h4><p>I don’t want to oversell this.</p><p>None of it gives you feedback from real users. We built what our research and our conversations with the industry expert said mattered. That’s a good start, but it isn’t validation. The sprint review exists so that users can push back, and we still need that. It’s arriving now as customers come on board, and I fully expect it to change things.</p><blockquote><em>Our slowest loop was always a human one. The longest delays came whenever we waited on an answer from outside the build. </em><strong><em>I</em></strong><em>n the end we stopped waiting: do the research, make the call, write down the reasoning and what would change it, and get on with it.</em><strong><em> </em></strong><em>That’s a retro lesson if ever there was one. We just learned it without the meeting.</em></blockquote><p>Experience cuts both ways, too. Two seasoned consultants can share exactly the same blind spot, and the answer to that is outside challenge, not another meeting.</p><p>This also works at our size. Put two teams with competing priorities on one product and some of that coordination will have to come back. The written rules will help, but they won’t make it go away.</p><p>And I can’t prove the counterfactual. I’m fairly confident full Scrum would have made us slower. Whether we’d have shipped fewer features is a separate question, and fewer isn’t always worse.</p><h4>🧭 Where I’ve landed</h4><p>I still believe in agile. I’m just a lot less attached to the rituals than I used to be. What matters is short feedback loops, small batches, lessons that stick and software you can ship at any time. The ceremonies were designed for a world where people were the bottleneck and building was expensive. With AI doing a lot of the building, the scarce things now are judgement and real user feedback, and any process I bring back will be aimed squarely at those.</p><p>I’m curious whether others delivering with AI are seeing the same thing. What did you keep, and what quietly fell away?</p><p>If you work with train wheel measurement data and want to see what two developers and a lot of written-down experience can build, have a look at <a href="https://wheelhub.io/">wheelhub.io</a> 🚆</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e39923866ef1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Tried Running Claude Code Locally. My GPU Had Other Ideas.]]></title>
            <link>https://medium.com/@nader.eloshaiker/i-tried-running-claude-code-locally-my-gpu-had-other-ideas-76c9be0d357f?source=rss-7e035b520d03------2</link>
            <guid isPermaLink="false">https://medium.com/p/76c9be0d357f</guid>
            <category><![CDATA[ollama]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[generative-ai-tools]]></category>
            <category><![CDATA[nvidia]]></category>
            <category><![CDATA[llm]]></category>
            <dc:creator><![CDATA[Nader Eloshaiker]]></dc:creator>
            <pubDate>Wed, 18 Nov 2026 10:14:09 GMT</pubDate>
            <atom:updated>2026-11-18T10:14:09.041Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ezby8lVNVtHw5JTvPP-ZmQ.jpeg" /></figure><p>I’ve spent some time experimenting with running local coding models with Claude Code.</p><p>The goal was fairly simple: could I get a good enough local setup running on my own hardware that I could reduce my dependence on hosted AI providers?</p><p>I already had a reasonably capable homelab, so it seemed like a fun engineering problem.</p><p>My setup was:</p><ul><li>QNAP NAS</li><li>64 GB RAM</li><li>Ryzen 7 2700</li><li>NVIDIA RTX 2000 Ada</li><li>16 GB VRAM</li><li>Ollama and Open WebUI running in Docker</li></ul><p>And, because apparently I enjoy making things harder for myself, I also tried vLLM.</p><p>The short version is: <strong>Ollama won for my use case, but neither local setup came close to replacing Claude Opus.</strong></p><p>And the reason turned out to be less about Ollama vs vLLM and much more about VRAM.</p><h4>Ollama vs vLLM</h4><p>I started with vLLM because it looked like the more serious option.</p><p>vLLM is designed for high-performance inference, high throughput and serving multiple users. If you’re building an AI service rather than running a model for yourself, there is a lot to like about it.</p><p>But I’m one developer with one GPU.</p><p>I’m not running an AI SaaS platform from my garage.</p><p>For my use case, Ollama was simply easier.</p><p>Docker integration was straightforward, NVIDIA GPU support worked well, models were easy to download and swap, and I didn’t have to spend my evenings becoming an unpaid inference-server administrator.</p><p>That simplicity mattered more to me than the additional capabilities of vLLM.</p><p>So I ended up sticking with Ollama.</p><h4>Then I met the 16 GB wall</h4><p>This was the more interesting part of the experiment.</p><p>16 GB of VRAM sounds like a reasonable amount.</p><p>It is.</p><p>Until you start asking a coding model to behave like Claude Opus.</p><p>The smaller models ran quite happily. But as I moved towards the larger models that were actually interesting for agentic coding, things got progressively less exciting.</p><p>Eventually the GPU says:</p><blockquote><em>“I have 16 GB.”</em></blockquote><p>The model says:</p><blockquote><em>“Excellent. I need more.”</em></blockquote><p>And Ollama says:</p><blockquote><em>“No problem. I’ll just put some of it in RAM.”</em></blockquote><p>Technically, this works.</p><p>My Ryzen 7 2700 wasn’t particularly enthusiastic about becoming a GPU, though.</p><p>Once significant parts of the model are being offloaded to system RAM and the CPU, performance drops pretty quickly. Increasing the context size makes the problem even more noticeable.</p><p>And context size matters a lot with Claude Code.</p><p>Claude Code isn’t just answering isolated questions. It’s working across a codebase, reading files, keeping track of previous actions and reasoning through multiple steps.</p><p>That means the combination of <strong>model size + context size + available VRAM</strong> becomes pretty important.</p><h4>And then there was Opus</h4><p>This was probably the biggest takeaway from the whole experiment.</p><p>I tried Qwen Coder and several other models that were genuinely impressive.</p><p>They could write code.</p><p>They could reason about code.</p><p>They could use tools.</p><p>They could do surprisingly sophisticated things locally.</p><p>But none of them came close to the overall experience I was getting from Claude with Opus for the type of coding work I was doing.</p><p>And I don’t think that’s entirely a criticism of the local models.</p><p>There are several things happening at once.</p><p>A large coding model needs memory.</p><p>A large context needs memory.</p><p>Agentic coding needs the model to repeatedly reason over that context.</p><p>And when you’re doing all of that on a 16 GB GPU, you eventually run into a fairly hard physical limit.</p><p>At that point, the engineering instinct kicks in:</p><p><strong>“I can probably fix this with hardware.”</strong></p><h4>Except NVIDIA had other ideas</h4><p>The obvious solution was more VRAM.</p><p>So I started looking at 24 GB and larger NVIDIA GPUs.</p><p>That’s where the economics became interesting.</p><p>The NVIDIA GPU prices I was seeing had roughly doubled compared with when I originally started looking at this.</p><p>Suddenly the calculation looked rather different.</p><p>Spend a significant amount of money upgrading the NAS.</p><p>Deal with GPU dimensions and power requirements.</p><p>Consume more electricity.</p><p>Spend time maintaining the setup.</p><p>And after all that, potentially still end up with something that isn’t as capable as simply using a hosted model.</p><p>At that point, the AI subscription starts looking surprisingly cheap.</p><h4>What I actually learned</h4><p>The experiment wasn’t a failure.</p><p>Quite the opposite.</p><p>I learned a lot about what local inference is good at.</p><p>Ollama is excellent for experimentation and for running smaller models locally. It’s simple, practical and very easy to integrate into a homelab.</p><p>Local models are also attractive when privacy, offline operation or control over your infrastructure is important.</p><p>But there’s a difference between:</p><p><strong>“Can I run an impressive AI model locally?”</strong></p><p>and:</p><p><strong>“Can I replace the experience I’m getting from Claude Opus?”</strong></p><p>For me, the answer to the first question is absolutely yes.</p><p>The answer to the second is currently no.</p><p>Not with the hardware I have.</p><p>And once I looked at what I’d need to change the answer, the economics stopped making much sense.</p><h4>My final scorecard</h4><p><strong>Ollama:</strong> 👍 Simple, practical and very well suited to a single-user setup.</p><p><strong>vLLM:</strong> 👍 Very capable, but more infrastructure than I needed for this particular job</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=76c9be0d357f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My AI playbook: the engineering discipline behind building with AI]]></title>
            <link>https://medium.com/@nader.eloshaiker/my-ai-playbook-the-engineering-discipline-behind-building-with-ai-c342622074ab?source=rss-7e035b520d03------2</link>
            <guid isPermaLink="false">https://medium.com/p/c342622074ab</guid>
            <category><![CDATA[developer-productivity]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[engineering-management]]></category>
            <dc:creator><![CDATA[Nader Eloshaiker]]></dc:creator>
            <pubDate>Wed, 18 Nov 2026 10:13:35 GMT</pubDate>
            <atom:updated>2026-11-18T10:13:35.684Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n5RjUIy4QCoqSyMyVHdwgw.jpeg" /></figure><p><em>What I’ve learned about context, quality and building software with AI.</em></p><p>Someone asked me about an “AI playbook” today. I’d never heard the term, but it got me thinking about how I use AI, how I manage context, and what it takes to keep code quality up when AI is involved in almost every part of development.</p><p>I’ve been working on a personal project for a few months, and I’m honestly surprised by how much I’ve built. But the biggest lesson isn’t how much code AI can write. It’s how much engineering discipline it takes to make that code worth shipping.</p><h3>1. You can’t be out of the loop</h3><p>“In the loop” and “out of the loop” have become very real to me on this project. If you’re shipping enterprise-grade software, being involved isn’t optional, and being involved means more than reviewing the final output. It means putting in the time to give AI the context it needs.</p><p>Generic context produces generic results. AI fills the gaps you leave with assumptions, and those may not match your product, architecture, business rules or standards. That’s true of every feature, bug fix and chore. You need to stay engaged, understand the changes, and check the outcome meets the bar you’ve set.</p><h4>Context is an engineering responsibility</h4><p>The quality of AI’s output depends heavily on the context you give it: repository structure, architecture, domain knowledge, past decisions, testing requirements and expected behaviour. The more complex the system, the more this matters. AI can speed up implementation, but it doesn’t know the history and reasoning behind your codebase unless you make that available.</p><h3>2. Your engineering standards must drive the outcome</h3><p>AI providers such as Anthropic, Google and OpenAI are businesses with their own goals. Speed, adoption and perceived value matter a lot to them. Your priorities may be maintainability, reliability, test coverage, security or long-term running cost. Both matter, but they aren’t the same thing, and your standards need to drive the output, not the assumptions built into the tool.</p><p>That’s why I think a useful AI playbook has to be more than a collection of prompts. It has to be part of the engineering system.</p><h3>3. My AI playbook</h3><p>The goal is simple: give AI the context, constraints and specialist knowledge it needs, while keeping the engineering oversight needed to ship quality software. Here’s how I’ve organised it.</p><h4>3.1 Instruction files: the map and shared rules</h4><p><strong>Where:</strong> AGENTS.md at the repository root and inside each app, such as apps/web-app/AGENTS.md and infra/AGENTS.md. CLAUDE.md just points to AGENTS.md, so the instructions live in one place.</p><p>These files map the repository and set shared conventions: what each part is responsible for, the shared engineering rules, how the product presents information to its users, commit conventions, and who owns which kind of work. The root file loads at the start of every session, and the app-level ones come into play when AI works in that app. The point is that nobody has to remember the structure and expectations.</p><h4>3.2 Rules: the things that must not be forgotten</h4><p><strong>Where:</strong> .agents/rules/</p><p>I have 12 focused rule files, such as releases.md, verification.md and api-contract.md. Each captures a lesson where ignoring the practice cost real time or added risk. A couple load in every session; the rest are read when the task matches, like editing the API spec or writing Go. That keeps the right constraints in front of the AI without loading everything every time, and it turns lessons learned into repeatable controls.</p><h4>3.3 Skills: reusable knowledge packs</h4><p><strong>Where:</strong> .agents/skills/, linked into .claude/skills/</p><p>Skills hold deeper knowledge about one subject: React, Go, the domain concepts specific to the product, and our ticket and workflow conventions. AI uses a skill when the task matches it, and until then only its one-line description is loaded. Specialist knowledge is there when it’s needed and costs almost nothing when it isn’t.</p><h4>3.4 Subagents: specialist perspectives</h4><p><strong>Where:</strong> .claude/agents/</p><p>I have 13 subagents, with roles such as react-developer, uiux-designer and design-system-engineer. They bring a specialist view, or take delegated work into their own worktree. The main session uses the routing guidance in AGENTS.md to decide when a specialist is worth it. It isn’t about handing over responsibility, it’s about bringing focused expertise to a task when it adds value.</p><h4>3.5 Product and design documentation: what the app does and why</h4><p><strong>Where:</strong> apps/web-app/docs/</p><p>These docs follow the product: pages/ explains each page that shows data, data/ explains each calculation, and design/ records how each built subsystem works. The rule is simple. If a change affects what a screen shows or how a number is calculated, the matching doc is updated in the same change. That keeps the code and the product behaviour it represents connected, for AI and for people.</p><h4>3.6 Repository documentation: how the system fits together</h4><p><strong>Where:</strong> docs/</p><p>This covers architecture.md (layout and naming), local-dev-instructions.md (running it locally), docs/api/ (agreements between the TypeScript frontend and the Go backend) and docs/proposals/ (designs not built yet). Once a proposal is built, its reasoning moves into the right doc. The root instructions point AI to the relevant section when it needs it.</p><h4>3.7 The decision log: keeping the reasoning</h4><p><strong>Where:</strong> docs/decisions.md</p><p>The log records what was decided, why, and what would make us revisit it. Nothing is deleted. If a new decision replaces an old one, the old one stays on record. Without this, AI will happily reopen a question that’s already been settled. The log keeps the reasoning, not just the answer.</p><h4>3.8 The board: the present and the future</h4><p><strong>Where:</strong> a GitHub Project</p><p>The board holds current and future work: backlog and ready columns for work with a clear definition of done, a “needs investigation” column for open questions (done once they produce real tickets), epics for related sub-tasks, P0 to P3 severity, and an owner on every card. AI can read cards, post progress, move statuses and leave handoff notes on epics so the next session can pick up where the last one stopped.</p><p>One principle matters most here: a fact lives in one place. Future work goes on the board, and past decisions go in the decision log.</p><h4>3.9 Acceptance fixtures: shared behaviour</h4><p><strong>Where:</strong> acceptance/</p><p>These are language-independent test cases for behaviour that more than one part of the system shares. Both the TypeScript and Go implementations have to pass them, which stops the two from quietly drifting apart. When shared behaviour changes, the fixture changes and both sides must pass it again.</p><h4>3.10 READMEs and code comments: local truth</h4><p><strong>Where:</strong> each package’s README.md, and the code itself</p><p>READMEs explain what a package is for and how to use it. Comments capture the reasoning behind non-obvious code, often with a link to a doc or ticket. Once something is built, the code is the source of truth, and this keeps useful context right next to it.</p><h4>3.11 Release notes: communicating change</h4><p><strong>Where:</strong> CHANGELOG.md and ANNOUNCEMENTS.md</p><p>The changelog is generated from commits, and the announcements are written for the product owner. Two skills, /create-release-log and /sync-announcement, do most of the work.</p><h4>3.12 AI memory: lessons from working together</h4><p><strong>Where:</strong> ~/.claude/projects/…/memory/</p><p>I keep 42 private notes outside the repository about how I like to work with AI, such as “merge only when I ask”, “use a worktree for this kind of work” and other workflow preferences. An index loads at the start of each session, so I don’t have to make the same correction twice.</p><h3>4. What this has changed</h3><p>The playbook is still evolving, but it’s changed how I think about AI-assisted development. I don’t spend much time on writing better prompts any more. I think about building an environment where AI has the right information, decisions are kept, behaviour is tested, and my engineering standards stay in control. The hard part isn’t generating code faster. It’s keeping the context and discipline to produce software that can be understood, tested, maintained and trusted.</p><h4>AI is an accelerator, not a substitute for engineering</h4><p>I think AI works best when its speed at processing information and writing code is paired with an engineer’s judgement and responsibility. That means staying involved, providing context, checking the result, and building the systems that make quality repeatable. AI doesn’t remove the need for engineering. It makes your engineering practices matter more.</p><p>I’m still refining this, and I’d like to hear from others building their own playbooks. What have you put in place, what’s worked, and where does AI still need the most guidance?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c342622074ab" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI writes code. Engineers take responsibility.]]></title>
            <link>https://medium.com/@nader.eloshaiker/ai-writes-code-engineers-take-responsibility-ec5bde8b3336?source=rss-7e035b520d03------2</link>
            <guid isPermaLink="false">https://medium.com/p/ec5bde8b3336</guid>
            <category><![CDATA[code-review]]></category>
            <category><![CDATA[mentorship]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Nader Eloshaiker]]></dc:creator>
            <pubDate>Wed, 18 Nov 2026 10:13:17 GMT</pubDate>
            <atom:updated>2026-11-18T10:13:17.416Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f7d06537aKDFwY1a5ViK3Q.jpeg" /></figure><p><em>What a bad fix from Claude taught me about code quality, junior engineers and “AI slop”.</em></p><p>I keep seeing the same moment. A junior engineer hits a wall, asks an AI assistant, gets something that compiles, and moves on. It looks like progress, but often it isn’t.</p><h3>“It works” isn’t the same as “it’s right”</h3><p>I’m not anti-AI. I use it every day, and not using it would feel like refusing to use a debugger. But using AI as a tool is different from handing it your thinking, and that line is getting blurry, especially for engineers early in their careers.</p><h3>A real example from this week</h3><p>I was wiring up TanStack Router in a monorepo. Fairly standard setup, but I couldn’t get type-safe routes working inside one of the app packages. After longer than I’d like to admit, I did what most of us do now and handed it to Claude (Opus 4.6 in this case).</p><p>It came back quickly with a fix. It compiled, type safety appeared to work, and the linter complained as expected when I deliberately broke a route. At a glance it looked solid.</p><h3>The code smelled wrong</h3><p>Then I actually read it. It had imported the auto-generated routeTree and cast a prop holding the destination route so the types would line up. No explanation, just a cast to make the compiler stop complaining.</p><p>If you’ve been around long enough, you feel that straight away. The code works, but it steps around the problem instead of solving it.</p><h3>The second attempt got it right</h3><p>So I pushed back. I explained why the cast was an anti-pattern and asked it to try again. With that bit of guidance it found the real issue almost immediately: I hadn’t defined a proper interface for the app router. A small omission, and the actual root cause.</p><p>What stuck with me wasn’t that the first answer was wrong. That’s expected. It’s that the first answer was exactly what a less experienced engineer might accept. It passed the obvious checks and removed the friction, so it looked correct.</p><h3>AI slop is real, and it’s subtle</h3><p>I’d call it AI slop: code that technically works but is structurally wrong, fragile or misguided. A decent code review used to catch it. Now it slips through more often because it looks polished. The danger isn’t that AI makes mistakes. It’s that its mistakes are convincing.</p><h3>What junior engineers risk losing</h3><p>A lot of learning in this industry comes from sitting in the discomfort: debugging something that doesn’t make sense, tracing types through a system, working out why a pattern exists. When AI skips that step, you lose more than time. You lose the mental model you would have built, and without it you can’t tell a clean solution from a hack.</p><h3>Where experienced engineers matter most</h3><p>If you’re experienced, your job isn’t only to use AI well. It’s to supervise it. Treat it like a very fast, very confident junior who will happily ship nonsense if nobody challenges it. Review its output like a pull request from someone still learning: ask why, look for shortcuts, and be suspicious of anything that felt too easy.</p><p>If you’re earlier in your career, the goal isn’t to avoid AI. It’s to use it without giving up ownership of the problem. If something comes back and you don’t fully understand it, slow down.</p><h3>The part AI can’t do for you</h3><p>An engineer’s value isn’t how quickly they produce code. It’s reasoning about systems, spotting bad ideas and making sound decisions with incomplete information. AI can help you move faster, but it can’t do that part. If we let it try, we’ll end up with a lot of code that works right up until it doesn’t.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ec5bde8b3336" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Running enterprise storage where it doesn’t belong: TrueNAS SCALE on a QNAP]]></title>
            <link>https://medium.com/@nader.eloshaiker/running-enterprise-storage-where-it-doesnt-belong-truenas-scale-on-a-qnap-53a8d852d3a9?source=rss-7e035b520d03------2</link>
            <guid isPermaLink="false">https://medium.com/p/53a8d852d3a9</guid>
            <category><![CDATA[qnap]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[homelab]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[truenas]]></category>
            <dc:creator><![CDATA[Nader Eloshaiker]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 08:05:34 GMT</pubDate>
            <atom:updated>2026-11-17T08:05:34.273Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gBlXx-XWsNnsnhxmNem7RA.png" /></figure><p>For years my QNAP TS-253D quietly did its job as the secondary backup NAS in my home lab. Not glamorous, but reliable, until I started asking what was actually running under the hood. That question ended with me moving it from QTS to TrueNAS SCALE.</p><p>This isn’t a how-to. It’s what I learned about security, bloat, containers, and what “enterprise-grade” means when you squeeze it onto consumer hardware.</p><h3>Why I looked beyond QTS</h3><p>QTS works, but it’s built around QNAP’s own ecosystem: lots of custom services, heavy reliance on QNAP-maintained apps, and a long history of publicly exploited vulnerabilities. QNAP’s own advisories show it. Many of the big attacks didn’t go after Samba or OpenSSH. They went after QNAP-specific services most owners didn’t know were running, and most of those services have better-maintained, widely used alternatives.</p><h3>TrueNAS SCALE puts security first</h3><p>TrueNAS SCALE is unapologetically built for the enterprise. It has a small attack surface, sensible defaults, a clear split between storage, system and applications, and it’s built on open standards. It doesn’t try to be a media server, photo manager and surveillance system out of the box. It’s a bare file server that expects you to add what you need, which these days means containers. That alone removes a lot of hidden risk.</p><h3>The Docker saga</h3><p>If you’ve followed the last few SCALE releases, you’ll know the app story has been turbulent:</p><ul><li><strong>Before 23.10:</strong> apps ran on Kubernetes (k3s), with Docker underneath.</li><li><strong>23.10 Cobia and 24.04 Dragonfish:</strong> the Docker runtime was removed in favour of containerd.</li><li><strong>24.10 Electric Eel:</strong> Kubernetes was removed and plain Docker came back, with Docker Compose support.</li></ul><p>From where I sat it felt less like a roadmap and more like a pendulum. iXsystems kept choosing what they thought was correct, first Kubernetes and then containerd, over what most of their users wanted, which was plain Docker. Where it ended up is better, but the swings cost confidence, especially for home lab users who sit somewhere between enterprise and consumer.</p><h3>Bloat versus composability</h3><p>This is where the contrast with QTS is starkest. QTS ships many tightly coupled, proprietary services that are hard to switch off, are a known attack vector, and give you little visibility into what’s running. SCALE is minimal by default, and everything else is opt-in through Docker with clear boundaries. If something is running on my TrueNAS box, it’s because I put it there. That makes it far easier to reason about and to secure.</p><h3>The fan control problem</h3><p>The biggest friction with SCALE on QNAP hardware is fan control. QNAP uses an IT8528 embedded controller that QTS drives through proprietary scripts and kernel modules, and SCALE understandably doesn’t support it.</p><p>The old workarounds meant extracting kernel modules from QTS, switching TrueNAS into developer mode and babysitting fragile dependencies. Not great for something meant to run unattended for years.</p><p>The open source community filled the gap:</p><ul><li><strong>qnap8528</strong>, an open replacement for the proprietary driver: <a href="https://github.com/0xGiddi/qnap8528">https://github.com/0xGiddi/qnap8528</a></li><li><strong>Truenas-qnap8528-module</strong>, a Docker-based build that avoids developer mode entirely: <a href="https://github.com/kylian-002/Truenas-qnap8528-module">https://github.com/kylian-002/Truenas-qnap8528-module</a></li></ul><p>I load the resulting module with insmod as a post-init task, so the base OS stays clean. For the control itself I run coolercontrold in a container (https://hub.docker.com/r/coolercontrol/coolercontrold), which gives me a proper UI, graphs, cooling curves I can draw, and sensible averaging. I now have more insight into my fans than QTS ever gave me.</p><h3>Enterprise software on consumer hardware</h3><p>To be clear, TrueNAS SCALE isn’t designed for this. I’m running an enterprise NAS OS on consumer hardware with no formal support, relying on GitHub projects, community knowledge and trial and error.</p><p>The forums aren’t always welcoming either. There’s a strong sense that if you’re not doing it the enterprise way, you’re doing it wrong, which ignores the home lab and prosumer crowd that helped TrueNAS grow in the first place. Even so, I’ll take some community friction over a bloated, opaque system.</p><h3>The QTS exit ramp is closing</h3><p>QTS itself is being phased out in favour of QuTS hero, which changes filesystem assumptions, limits upgrade paths and forces architectural decisions sooner. For older devices that means less runway every year, so moving early gave me control back.</p><h3>Final thoughts</h3><p>This wasn’t about chasing something new. I wanted a smaller attack surface, a system I actually own, composability over convenience, and transparency even if it costs some friction. SCALE isn’t perfect, and its app strategy hasn’t always inspired confidence, but at its core it treats security and architecture as first-class concerns. For me that was worth the trade-offs.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=53a8d852d3a9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[When frontend meets backend: the hidden security cost of modern React]]></title>
            <link>https://medium.com/@nader.eloshaiker/when-frontend-meets-backend-the-hidden-security-cost-of-modern-react-9823bd59ea55?source=rss-7e035b520d03------2</link>
            <guid isPermaLink="false">https://medium.com/p/9823bd59ea55</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[frontend-development]]></category>
            <category><![CDATA[nextjs]]></category>
            <category><![CDATA[web-security]]></category>
            <dc:creator><![CDATA[Nader Eloshaiker]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 08:05:09 GMT</pubDate>
            <atom:updated>2026-11-17T08:05:09.269Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fJ51HTqqjsRylWhK_5QsIA.jpeg" /></figure><p><em>Blurring the line between UI and data buys speed, and it can cost you security. Here’s how I’d keep the boundaries that protect an app.</em></p><h3>How it used to look</h3><pre>Browser  &lt;-&gt;  SPA (React, Angular, Vue)  &lt;-&gt;  REST or GraphQL API</pre><p>The UI never touched the database or the business logic. The only thing exposed to the internet was a small set of API endpoints, and the contract between the two sides was explicit: JSON schemas, OpenAPI docs or GraphQL types. Frontend developers could focus on components, state and user flows without worrying about where the data lived.</p><h3>Then the lines started to blur</h3><p>For better performance, SEO and faster first paint, frameworks moved more work to the server, one step at a time:</p><ul><li><strong>Server-side rendering.</strong> The server sends HTML as a snapshot. There’s still a clear API boundary.</li><li><strong>Server actions</strong> (Next.js, Remix and others). A component calls the server directly, with no explicit REST endpoint in between.</li><li><strong>Generated actions.</strong> Actions are generated from the data model at build time. No /api folder, and no contract to maintain.</li><li><strong>Database calls in React Server Components.</strong> With Drizzle or Prisma, a component that runs on the server can query the database itself. The component is now the backend.</li></ul><p>Each step made developers’ lives easier. Fetching and mutating data happens in one place, there’s less boilerplate, and you can change the UI and its logic in the same file.</p><h3>Where speed becomes an attack surface</h3><p>The more backend logic lives in frontend code, the bigger the attack surface.</p><h4>React2Shell (CVE-2025–55182)</h4><p>In December 2025 a critical vulnerability in React Server Components allowed remote code execution on the server through a crafted request. Follow-up fixes covered source code exposure and denial of service on the same endpoints. Patching it meant upgrading React and the frameworks that bundle it, quickly.</p><p>It made a hard point clear. When the frontend doubles as the backend, a framework bug or a developer’s mistake can become a full server compromise.</p><h4>Other risks I watch for</h4><ul><li><strong>Leaked credentials.</strong> Secrets in server-side component code end up in a build artefact or a log.</li><li><strong>Injection.</strong> A database call written inside a component skips the validation a service layer would have done.</li><li><strong>Business-logic bypass.</strong> A server action is a public endpoint. Anyone can call it directly and skip the checks the UI does, so an admin-only action runs for a normal user.</li><li><strong>Accidental data exposure.</strong> Server rendering serialises more of an object than the page needs, and the rest shows up in the network tab.</li></ul><h3>The race to the bottom</h3><p>Better user experience, fewer files and one deployment target are all good goals. Together they tempt teams to remove the fence between frontend and backend, and then security is a side effect instead of a design goal. When any component can talk to the database, the guardrails that protected data, credentials and business rules go with the fence.</p><h3>Putting healthy boundaries back</h3><p>You don’t have to give up modern tooling. Treat boundaries as deliberate abstractions.</p><h4>Keep a contract layer</h4><p>Even with generated actions, expose a small typed contract (TypeScript interfaces, an OpenAPI spec or a GraphQL schema) and version it like any public API.</p><h4>Separate the concerns</h4><ul><li><strong>UI:</strong> presentation and interaction, in React, Solid or Svelte.</li><li><strong>Business logic:</strong> validation and orchestration, in server actions that call dedicated service functions.</li><li><strong>Data access:</strong> queries and caching, in Prisma, Drizzle or TypeORM, behind those services.</li><li><strong>Security:</strong> authentication, authorisation and secrets, in middleware or an identity provider such as Auth0.</li></ul><p>With clear layers, a bug in one can’t easily leak into another.</p><h4>Harden the runtime</h4><ul><li>Send security headers such as Content-Security-Policy and X-Frame-Options.</li><li>Rate-limit server action and RSC endpoints. They’re on the internet like any other endpoint.</li><li>Log every database write with who made it and from where.</li><li>Give the database user only the rights it needs.</li></ul><h4>Check it in CI</h4><ul><li>Static analysis for hard-coded secrets and misused environment variables.</li><li>Dependency scanning, so the next React2Shell is a version bump rather than a surprise.</li><li>Automated security tests aimed at server action and RSC endpoints.</li></ul><h3>Final thought</h3><p>The line between frontend and backend has blurred to the point where it’s easy to forget we’re still building software that has to be secure. Keep that line visible and enforce it in code. A good user experience starts with a secure, predictable one.</p><p>Have you moved backend logic into the frontend? I’d like to hear whether you saw a security trade-off.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9823bd59ea55" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From React Router 5 to TanStack Router: modernising a legacy React template in one sprint]]></title>
            <link>https://medium.com/@nader.eloshaiker/from-react-router-5-to-tanstack-router-modernising-a-legacy-react-template-in-one-sprint-275ef7bbe856?source=rss-7e035b520d03------2</link>
            <guid isPermaLink="false">https://medium.com/p/275ef7bbe856</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[frontend-development]]></category>
            <category><![CDATA[tanstack]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Nader Eloshaiker]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 08:04:27 GMT</pubDate>
            <atom:updated>2026-11-17T08:04:27.931Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*897juL1Zlwfi9dYlOTA8sg.jpeg" /></figure><p>Replacing a core library in an organisation’s template is always a gamble. I expected a cascade of regressions. What I got was fewer bugs, clearer code and a happier team.</p><h3>The problem: a router that had become legacy</h3><p>When I joined my current squad, React Router 5 was the standard. It had served the team well, but it felt more like a legacy system than a modern, type-safe API. These were the pain points that made me want to change it:</p><ul><li><strong>Boilerplate.</strong> &lt;Route path=”/app” component={App} /&gt; repeated over and over, and more lines meant more places to break.</li><li><strong>Auth guards everywhere.</strong> A separate PrivateRoute component plus if (!user) checks scattered through the codebase.</li><li><strong>Route errors at runtime.</strong> A typo like to=”/dashbord” failed silently and only showed up in production.</li><li><strong>Testing friction.</strong> MemoryRouter and hand-written history mocks made tests brittle.</li><li><strong>Performance.</strong> Code splitting was manual with React.lazy and Suspense, and there was no shared approach to prefetching data.</li></ul><p>A code freeze gave us the opening: a window to make a foundational change without blocking feature work.</p><h3>The decision: TanStack Router with file-based routing</h3><p>TanStack Router offered exactly what we were missing. Routes come from file and folder names instead of manual config, route parameters are typed, routes are code-split automatically, and a single beforeLoad hook can guard a whole folder.</p><h3>How we migrated</h3><p>Everything below happened on a feature branch that didn’t touch main until the migration had been thoroughly tested.</p><h4>1. Install alongside the old router</h4><pre># keep the old router while migrating<br>npm install react-router-dom@5<br># add the new router and its Vite plugin<br>npm install @tanstack/react-router<br>npm install -D @tanstack/router-plugin</pre><p>Then add the plugin to vite.config.ts, before the React plugin, so it generates the route tree from your files:</p><pre>import { tanstackRouter } from &#39;@tanstack/router-plugin/vite&#39;<br>import react from &#39;@vitejs/plugin-react&#39;</pre><pre>export default defineConfig({<br>  plugins: [tanstackRouter({ target: &#39;react&#39;, autoCodeSplitting: true }), react()],<br>})</pre><h4>2. Centralise authentication first</h4><p>Before touching the router, we put authentication in one place, a context and a useAuth hook:</p><pre>// src/auth/AuthContext.tsx<br>export const AuthContext = React.createContext&lt;{<br>  user: User | null<br>  startLogin: (options: { redirectPathName: string }) =&gt; Promise&lt;void&gt;<br>  logout: () =&gt; void<br>} | null&gt;(null)</pre><p>The router’s beforeLoad guard reads from this later.</p><h4>3. Lay out the route tree</h4><p>We mirrored the existing public and private structure. A folder starting with an underscore is a layout that adds no segment to the URL, which makes it the natural place for the guard, and $id marks a route parameter:</p><pre>src/routes/<br>  __root.tsx<br>  index.tsx            -&gt; /<br>  about.tsx            -&gt; /about<br>  _auth.tsx            -&gt; guard for everything in _auth/<br>  _auth/<br>    dashboard.tsx      -&gt; /dashboard<br>    settings.tsx       -&gt; /settings<br>  users/<br>    index.tsx          -&gt; /users<br>    $id.tsx            -&gt; /users/:id</pre><h4>4. Create the router with a typed auth context</h4><pre>// src/routes/__root.tsx<br>import { createRootRouteWithContext, Outlet } from &#39;@tanstack/react-router&#39;<br>import type { useAuth } from &#39;../auth/useAuth&#39;</pre><pre>export interface AppRouterContext {<br>  auth: ReturnType&lt;typeof useAuth&gt;<br>}</pre><pre>export const Route = createRootRouteWithContext&lt;AppRouterContext&gt;()({<br>  component: () =&gt; &lt;Outlet /&gt;,<br>})</pre><pre>// src/router.tsx<br>import { createRouter, RouterProvider } from &#39;@tanstack/react-router&#39;<br>import { routeTree } from &#39;./routeTree.gen&#39;<br>import { useAuth } from &#39;./auth/useAuth&#39;</pre><pre>export const router = createRouter({ routeTree, context: { auth: undefined! } })</pre><pre>declare module &#39;@tanstack/react-router&#39; {<br>  interface Register {<br>    router: typeof router<br>  }<br>}</pre><pre>export function AppRouterProvider() {<br>  const auth = useAuth()<br>  return &lt;RouterProvider router={router} context={{ auth }} /&gt;<br>}</pre><p>The Register declaration is what makes every Link and navigate call type-checked against your real routes.</p><h4>5. Guard a whole folder with beforeLoad</h4><p>beforeLoad runs before any route under _auth renders, so it’s the one place the auth check lives:</p><pre>// src/routes/_auth.tsx<br>import { createFileRoute, Outlet } from &#39;@tanstack/react-router&#39;</pre><pre>export const Route = createFileRoute(&#39;/_auth&#39;)({<br>  beforeLoad: async ({ context, location }) =&gt; {<br>    if (!context.auth.user) {<br>      await context.auth.startLogin({ redirectPathName: location.href })<br>    }<br>  },<br>  component: () =&gt; &lt;Outlet /&gt;,<br>})</pre><p>No more if (!user) checks sprinkled through components.</p><h4>6. Replace Link and history.push</h4><pre>// before (React Router 5)<br>import { Link } from &#39;react-router-dom&#39;<br>&lt;Link to=&quot;/dashboard&quot;&gt;Dashboard&lt;/Link&gt;</pre><pre>// after<br>import { Link, useNavigate } from &#39;@tanstack/react-router&#39;<br>&lt;Link to=&quot;/dashboard&quot;&gt;Dashboard&lt;/Link&gt;</pre><pre>const navigate = useNavigate()<br>navigate({ to: &#39;/dashboard&#39;, replace: true })</pre><p>The syntax barely changes, but both are now checked at compile time, so to=”/dashbord” is a type error instead of a production bug.</p><h4>7. Convert dynamic routes</h4><pre>// src/routes/users/$id.tsx<br>import { createFileRoute } from &#39;@tanstack/react-router&#39;</pre><pre>export const Route = createFileRoute(&#39;/users/$id&#39;)({<br>  component: UserPage,<br>})</pre><pre>function UserPage() {<br>  const { id } = Route.useParams() // typed as string<br>  // fetch the user and render<br>}</pre><h4>8. Reusable, typed links</h4><p>linkOptions lets you build a link once and reuse it, still fully typed:</p><pre>import { Link, linkOptions } from &#39;@tanstack/react-router&#39;</pre><pre>const userLink = linkOptions({ to: &#39;/users/$id&#39;, params: { id: user.id } })</pre><pre>return &lt;Link {...userLink}&gt;{user.name}&lt;/Link&gt;</pre><h4>9. Remove React Router</h4><p>Once every route, link and navigation call was migrated, we uninstalled react-router-dom and replaced the BrowserRouter wrapper:</p><pre>import ReactDOM from &#39;react-dom/client&#39;<br>import { AppRouterProvider } from &#39;./router&#39;</pre><pre>ReactDOM.createRoot(document.getElementById(&#39;root&#39;)!).render(&lt;AppRouterProvider /&gt;)</pre><h4>10. Update the tests (Vitest)</h4><p>Tests now build a real router over in-memory history, so they exercise the same routing as production:</p><pre>import { createMemoryHistory, createRouter, RouterProvider } from &#39;@tanstack/react-router&#39;<br>import { render, screen } from &#39;@testing-library/react&#39;<br>import { routeTree } from &#39;../routeTree.gen&#39;</pre><pre>it(&#39;renders the home page&#39;, async () =&gt; {<br>  const router = createRouter({<br>    routeTree,<br>    history: createMemoryHistory({ initialEntries: [&#39;/&#39;] }),<br>    context: { auth: mockAuth },<br>  })</pre><pre>  render(&lt;RouterProvider router={router} /&gt;)</pre><pre>  expect(await screen.findByRole(&#39;heading&#39;, { name: &#39;Home&#39; })).toBeInTheDocument()<br>})</pre><h4>11. Clean up and check performance</h4><ul><li>Remove any stray react-router imports.</li><li>Check in the Network tab that route components load lazily.</li><li>Run a bundle analysis.</li><li>Document the new folder structure and guard flow in CONTRIBUTING.md.</li></ul><h3>The results</h3><p>Roughly, from our project: the routing code shrank to about a quarter of its old size, auth checks went from more than ten components to a single beforeLoad guard, the bundle came out about a third smaller, and test upkeep dropped from a few hours a week to around one.</p><p>The benefit that’s hardest to measure is the developer experience. Drop a file in the right folder and the router picks it up.</p><h3>What I learned</h3><ul><li><strong>Migrate on a branch.</strong> Keep main untouched until everything passes CI.</li><li><strong>Guard once.</strong> beforeLoad plus one auth context is far cleaner than checks in every component.</li><li><strong>Let the types catch it.</strong> Typed links, linkOptions and useParams turn route typos into compile errors.</li><li><strong>Test against the real router.</strong> It’s the only way to catch navigation bugs early.</li><li><strong>Performance comes for free.</strong> Automatic code splitting gave us quick wins without extra work.</li></ul><h3>Takeaway</h3><p>If your team is still on React Router 5, don’t wait for another major version. A quiet window, like a code freeze, plus a dedicated branch is enough to do it, and it will save you a lot of technical debt over the next year or two. File-based routing, beforeLoad guards and one auth context turned our routing layer into a single, typed source of truth with very little boilerplate.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=275ef7bbe856" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Cut E2E test time to a tenth with API contracts and code generation]]></title>
            <link>https://medium.com/@nader.eloshaiker/cut-e2e-test-time-to-a-tenth-with-api-contracts-and-code-generation-038702e75378?source=rss-7e035b520d03------2</link>
            <guid isPermaLink="false">https://medium.com/p/038702e75378</guid>
            <category><![CDATA[playwright-test]]></category>
            <category><![CDATA[openapi-specification]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[frontend-development]]></category>
            <category><![CDATA[test-automation]]></category>
            <dc:creator><![CDATA[Nader Eloshaiker]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 08:03:31 GMT</pubDate>
            <atom:updated>2026-11-17T08:03:31.452Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YWf9eLV7zJ2YAfBqN7JN4g.jpeg" /></figure><p><strong>In short:</strong> work contract-first. Generate the client, the data models and the mock handlers from your OpenAPI spec, then point Playwright at those mocks. Your end-to-end tests become fast, repeatable and isolated, with no real logins, no rate limits and no test data left in a database.</p><h3>1. Why traditional E2E testing hurts</h3><p>What I wanted was simple: run Playwright end-to-end tests without hitting the real backend, logging in with MFA, or tripping the identity provider’s rate limit. In practice most of us end up writing a lot of plumbing instead:</p><ul><li><strong>Login flows:</strong> OAuth, MFA, one-time codes, SAML.</li><li><strong>Test data:</strong> creating, updating and cleaning up records for every scenario.</li><li><strong>Rate limits:</strong> real identity providers throttle repeated logins, and tests start failing at random.</li><li><strong>Speed:</strong> every step goes over the network to a live server, so CI crawls.</li></ul><p>The result is a slow, brittle, expensive suite that still doesn’t cover much of what users actually do.</p><h3>2. What API contracts and code generation give you</h3><h4>Why a contract</h4><p>An OpenAPI spec is a typed description of every endpoint, request and response your app uses. Build your testing on it and you get one source of truth for the client, the mocks and the docs, TypeScript types that keep the UI and the tests aligned, and early warning when the API changes, because the generated code changes with it.</p><h4>What the generators do</h4><ul><li><strong>orval</strong> generates a typed client (fetch, axios or React Query hooks), data models, and MSW mock handlers filled with realistic fake data.</li><li><strong>MSW (Mock Service Worker)</strong> intercepts requests, in the browser or in Node, and answers them from those handlers.</li></ul><p>Together they give you a mock backend that implements exactly the contract you’re testing against, data that’s realistic but predictable, and no real authentication, because the login endpoint is mocked too.</p><h3>3. From spec to Playwright</h3><p>The goal: a Playwright test that checks “a user can see their dashboard after logging in” without touching the real backend.</p><h4>3.1 Define the contract</h4><pre># openapi.yaml<br>openapi: 3.0.1<br>info:<br>  title: My App API<br>  version: 1.0.0<br>paths:<br>  /auth/login:<br>    post:<br>      operationId: login<br>      requestBody:<br>        content:<br>          application/json:<br>            schema:<br>              $ref: &#39;#/components/schemas/LoginRequest&#39;<br>      responses:<br>        &#39;200&#39;:<br>          description: Success<br>          content:<br>            application/json:<br>              schema:<br>                $ref: &#39;#/components/schemas/LoginResponse&#39;<br>  /dashboard:<br>    get:<br>      operationId: getDashboard<br>      responses:<br>        &#39;200&#39;:<br>          description: Dashboard data<br>          content:<br>            application/json:<br>              schema:<br>                $ref: &#39;#/components/schemas/Dashboard&#39;<br>components:<br>  schemas:<br>    LoginRequest:<br>      type: object<br>      properties:<br>        email: { type: string }<br>        password: { type: string }<br>    LoginResponse:<br>      type: object<br>      properties:<br>        token: { type: string }<br>    Dashboard:<br>      type: object<br>      properties:<br>        userName: { type: string }<br>        stats: { type: array, items: { type: number } }</pre><h4>3.2 Generate the client and the mocks</h4><pre>// orval.config.ts<br>import { defineConfig } from &#39;orval&#39;</pre><pre>export default defineConfig({<br>  api: {<br>    input: &#39;./openapi.yaml&#39;,<br>    output: {<br>      target: &#39;./src/api/client.ts&#39;,<br>      client: &#39;axios&#39;,<br>      mock: true, // also writes MSW handlers with faker data<br>    },<br>  },<br>})</pre><pre>npx orval</pre><p>Besides the typed client, orval writes a client.msw.ts file with one handler per operation, such as getGetDashboardMockHandler, each of which accepts an override so a test can pin the exact response it needs. The exact signature varies between orval versions, so check the generated file.</p><h4>3.3 Serve the mocks to Playwright</h4><p>@mswjs/http-middleware turns MSW handlers into a small HTTP server, so the app under test can call it like a real API. Start the app with its API base URL pointing at that server, here <a href="http://localhost:4000.">http://localhost:4000.</a></p><pre>// tests/dashboard.spec.ts<br>import { test, expect } from &#39;@playwright/test&#39;<br>import { createServer } from &#39;@mswjs/http-middleware&#39;<br>import { getLoginMockHandler, getGetDashboardMockHandler } from &#39;../src/api/client.msw&#39;</pre><pre>let server: ReturnType&lt;ReturnType&lt;typeof createServer&gt;[&#39;listen&#39;]&gt;</pre><pre>test.beforeAll(() =&gt; {<br>  server = createServer(<br>    getLoginMockHandler({ token: &#39;test-token&#39; }),<br>    getGetDashboardMockHandler({ userName: &#39;John Doe&#39;, stats: [1, 2, 3, 4, 5] }),<br>  ).listen(4000)<br>})</pre><pre>test.afterAll(() =&gt; {<br>  server.close()<br>})</pre><pre>test(&#39;shows user stats after login&#39;, async ({ page }) =&gt; {<br>  await page.goto(&#39;http://localhost:3000&#39;)<br>  await page.getByLabel(&#39;Email&#39;).fill(&#39;user@example.com&#39;)<br>  await page.getByLabel(&#39;Password&#39;).fill(&#39;password&#39;)<br>  await page.getByRole(&#39;button&#39;, { name: &#39;Log in&#39; }).click()</pre><pre>  await expect(page.getByTestId(&#39;user-name&#39;)).toHaveText(&#39;John Doe&#39;)<br>  await expect(page.locator(&#39;.stat&#39;)).toHaveCount(5)<br>})</pre><p>Why it works: the handlers come straight from the spec, the overrides make each scenario deterministic, the generated client means the UI breaks at compile time if the contract changes, and the whole run stays local, with no network latency and no login to get through.</p><h3>4. What changed for us</h3><ul><li><strong>Login and MFA:</strong> the real OAuth and one-time-code dance became a mocked login response, and login flakiness went away.</li><li><strong>Rate limits:</strong> the identity provider used to throttle us after a handful of logins. With an in-memory mock there’s no limit.</li><li><strong>Test data:</strong> no more creating and deleting users. Fixtures come from the spec, so nothing touches a database.</li><li><strong>Speed:</strong> scenarios went from a few seconds each to under a second, and the suite runs in roughly a tenth of the time.</li><li><strong>Flakiness:</strong> deterministic responses made flaky runs rare.</li><li><strong>Maintenance:</strong> hand-written mocks and helpers were mostly replaced by generated code, so there’s far less to keep up to date.</li></ul><h3>5. Limits, and when to test the full stack</h3><ul><li><strong>Real integration:</strong> you still need some tests against the real server.</li><li><strong>Third-party APIs:</strong> if your app calls external services, mock those separately.</li><li><strong>Data-heavy UI:</strong> screens that depend on complex related data may need a small in-memory database behind the mocks.</li><li><strong>Performance testing:</strong> use a real load-testing tool such as k6 or Gatling. Mocks aren’t built for that.</li></ul><p>Mock-based E2E is a strong first layer. It lets you run a lot of fast, reliable scenarios on every commit. Keep a small set of real tests against the live stack to prove the contract holds with the real services.</p><h3>6. Practices that keep it working</h3><ul><li>Regenerate the client and mocks whenever the spec changes.</li><li>Let orval’s faker integration generate realistic data, and override only what a test asserts on.</li><li>Version the mocks with the spec so they never drift apart.</li><li>Run a small nightly set of real tests that hit the live database and identity provider.</li><li>In CI, give each job its own mock port so parallel runs don’t clash.</li></ul><h3>7. Takeaway</h3><p>If you can trust a contract and a generator to give you a complete, typed and deterministic API layer, you no longer have to put up with slow, flaky end-to-end tests. You drop the login friction and the database clean-up, the suite gets much faster, and the code stays typed and DRY. Your tests can focus on what users actually experience.</p><h3>Want to try it?</h3><ol><li>Start from the OpenAPI spec you already have.</li><li>Run orval with mock: true to generate the client and the MSW handlers.</li><li>Serve the handlers with @mswjs/http-middleware, or use MSW directly in the browser.</li><li>Point Playwright at it and compare the run time.</li></ol><p>One tip: add a generate:api script that regenerates everything, and run it before the tests in CI. That way you never test against a stale contract.</p><p>If you’d like help setting up the tooling, or want to go deeper on mocking strategies, get in touch.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=038702e75378" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[One rulebook, any AI assistant: how two of us run our coding agents]]></title>
            <link>https://medium.com/@nader.eloshaiker/one-rulebook-any-ai-assistant-how-two-of-us-run-our-coding-agents-30908598d40d?source=rss-7e035b520d03------2</link>
            <guid isPermaLink="false">https://medium.com/p/30908598d40d</guid>
            <dc:creator><![CDATA[Nader Eloshaiker]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 07:35:28 GMT</pubDate>
            <atom:updated>2026-11-17T07:35:28.350Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KFenZY9F_MhGPcU-" /></figure><p>Two of us are building a data analytics platform, with AI agents doing a lot of the building. We didn’t start on the same tool: I used Claude Code, and my teammate used Antigravity, both working from the same rulebook. He has since moved to Claude Code too, but the rules still name no single assistant.</p><p>The most valuable thing in our repo might be the rulebook. Every time an agent got something wrong and it cost us real time, we wrote down what should have happened: how to brief a <strong>builder</strong> (the agent that writes the code), when to open a browser and actually look at the screen, why you don’t merge while a check is still red.</p><p>Those rules only pay off if every assistant can read them. Here’s the whole approach in four moves, one section each:</p><ol><li><strong>One file holds every rule.</strong> Each AI tool gets an <strong>adapter</strong>: a one-line pointer to that file, never a copy.</li><li><strong>Rules describe the job, not the product.</strong> They say “the <strong>frontier model tier</strong>” (the strongest model available), not “Opus”. One small table, the <strong>provider map</strong>, translates each term for each tool.</li><li><strong>Only what the task needs gets loaded.</strong> The basics every time, everything else on demand.</li><li><strong>Lessons go in the rulebook, not in one tool’s memory.</strong> If any agent would need it, it’s written where all of them read.</li></ol><p>What it gets us: both assistants have worked from the same rules, it costs no extra steps per task (I measured it), and 18 hard-won lessons that only one tool knew are now shared.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*I7_p__4vZws4KQdbyPYkjg.png" /></figure><h3>1. One file holds every rule</h3><p>Every rule lives in one file, <strong>AGENTS.md</strong>: an open format that most coding assistants read natively, including Codex, Cursor and GitHub’s Copilot agent. Each assistant’s adapter points to it from the place that assistant already looks. For Claude Code, that’s a CLAUDE.md file whose only real line imports AGENTS.md.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YMkBgOvpP_Bv_AbSYQOf2g.png" /></figure><p>Only the adapters know which assistant is running. My teammate worked from this same rulebook in Antigravity before he moved to Claude Code.</p><p>The same goes for <strong>skills</strong> (how-to guides an agent loads when a task matches them) and <strong>subagents</strong> (specialist agents the main one hands work to). They live once, in a shared .agents folder, and each assistant’s own folder just links back. We keep no copies, because copies drift and then nobody can tell which one is current.</p><p>Here’s the whole of our root CLAUDE.md, and what Claude’s own folder holds. Each app has the same one-line CLAUDE.md beside its own AGENTS.md.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xwa3MoZFUXx1mbGpfHhGsQ.png" /></figure><h3>2. Rules describe the job, not the product</h3><p>The rules never lean on a model or tool name. They say “use the frontier model tier” rather than “use Opus”, and “run it in the background” rather than one tool’s flag for it.</p><p>The provider map translates each of those terms for each assistant. In Claude Code the frontier tier is Opus and the fast tier is Sonnet. Supporting another assistant means adding a column to the map, not editing every rule.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bc5gd3W5GLfGCZD8xSSjNQ.png" /></figure><p>There’s one exception. In four <strong>hot spots</strong>, places where a missed lookup leads to rework, the rule also names today’s value in brackets straight after the neutral term: “the frontier model tier (Claude Code: Opus)”. That’s a <strong>bracketed value</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_zxtYGdPGa0wgwecGVQMgA.png" /></figure><h4>Does that cost anything? I measured it</h4><p>Every time an agent stops to look something up, that’s another <strong>turn</strong>: one more round trip to the model, and you pay for each one. So I measured whether the neutral wording adds turns.</p><p>I ran fresh <strong>headless</strong> Claude Code sessions (started from a script, with nobody at the keyboard) and asked each one the three things every builder’s brief needs: which model to use, how to load the <strong>language server</strong> (the tool that knows exactly what calls what in the code), and how to run tests safely while other sessions are running. Two runs per setup, and every run got all three right.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*By9rIomaRJvw-Gk96jmOgA.png" /></figure><p>With the values kept only in the provider map, the agent needed an extra turn to open it and learn that “frontier tier” means Opus. That makes sense: an assistant knows its own model names, but it can’t know which one your repo means by a tier. With a bracketed value at each hot spot, it needed one turn fewer than plain product names. The <strong>context</strong>, everything the model reads before it starts work, was about 37,000 tokens either way.</p><p>The extra turn isn’t the real cost, though. Rework is. Four agents once told only to “use the language server” used it twice, and fell back on <strong>grep</strong>, plain text search, about 1,200 times. Naming the exact tool at the hot spots is what stops that.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wGk6-OXQppt_bvKnOvqA9A.png" /></figure><h3>3. Only what the task needs gets loaded</h3><p>One rulebook doesn’t mean loading all of it. Everything in the context is paid for on every turn, so the rules are <strong>routed</strong>: each piece loads only when something calls for it.</p><p>Only the root AGENTS.md and two rules that apply to every change load every time, about 7,000 tokens. Each app has its own AGENTS.md that loads when an agent works in that app. The other 13 rules sit behind a table that tells the agent which one to read before which kind of work. Skills and subagents show only a one-line description until one is used.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LNKKwlz7v3fs__PoGTiGCA.png" /></figure><p>A file that loads every time holds the rules, and the reasoning behind them sits next door. Agents need the rule on every task, but the why only when they’re changing it.</p><h3>4. Lessons go in the rulebook, not in one tool’s memory</h3><p>Claude Code keeps a private <strong>memory</strong>: short notes it saves when you correct it. It lives on my machine, outside git, so my teammate never sees it and neither does any other assistant.</p><p>So the rule is simple. A lesson that’s only about me, like how I want things explained or how my machine is set up, stays in memory. A lesson any agent would need goes into the rulebook.</p><p>Sorting the memory against that rule paid off. Of 60 notes, 18 were team lessons that existed nowhere else.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ciFzZfZnge8r9ha-xN2VOA.png" /></figure><p>They weren’t small ones either: a pull request merged while a check was failing, a branch clean-up whose wildcard deleted about 50 branches, and a change of folder that failed silently, so a git command ran in the shared checkout instead of the agent’s own <strong>worktree</strong> (a separate copy of the repo each agent works in). Each was learned once, by one assistant, for one person. Now every agent reads them.</p><h3>What I’d tell anyone doing the same</h3><p>If you build with AI agents, your instructions are probably the most valuable thing you’ve written. Give them the same care as the code: keep one copy, write it for the job rather than the tool, load only what each task needs, and add to it every time an agent gets something wrong.</p><p>One honest gap: the measurements here were all made with Claude Code. The rulebook itself has run in Antigravity, where my teammate worked from it every day, but I haven’t measured turns there. I also tried GitHub Copilot CLI and was blocked by an account policy, and I haven’t installed Codex yet.</p><p>Is anyone else keeping one set of AI rules across more than one assistant? I’d like to hear what broke.</p><p>#ClaudeCode #Antigravity #AGENTSmd #AIEngineering #SoftwareEngineering #DeveloperTools #GenerativeAI</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=30908598d40d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Your NAS disks never spin down? A free fix for OpenMediaVault and WD Red drives]]></title>
            <link>https://medium.com/@nader.eloshaiker/your-nas-disks-never-spin-down-a-free-fix-for-openmediavault-and-wd-red-drives-986f95cf27f3?source=rss-7e035b520d03------2</link>
            <guid isPermaLink="false">https://medium.com/p/986f95cf27f3</guid>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[openmediavault]]></category>
            <category><![CDATA[homelab]]></category>
            <category><![CDATA[self-hosted]]></category>
            <category><![CDATA[nas]]></category>
            <dc:creator><![CDATA[Nader Eloshaiker]]></dc:creator>
            <pubDate>Sat, 07 Nov 2026 07:29:44 GMT</pubDate>
            <atom:updated>2026-11-07T07:29:44.199Z</atom:updated>
            <content:encoded><![CDATA[<h4>A small, free plugin that puts idle hard disks to sleep when they ignore their own spindown timer, without ever waking a sleeping disk.</h4><figure><img alt="Banner: openmediavault-spindown, free and open source. Let your hard disks sleep, for disks that ignore their spindown time in OpenMediaVault, such as WD Reds. Beside it, the Spin down page with two disks asleep" src="https://cdn-images-1.medium.com/max/1024/1*daI4epX2tG4kjuFk_Q2GqQ.png" /></figure><p>I run OpenMediaVault on a QNAP TS-253D with two 12 TB WD Red drives in a ZFS mirror. They hold backups, so most of the day nothing touches them. For a long time they went to sleep after ten minutes, as set in OpenMediaVault. Then one day they stopped. They spun all day and all night, using power and wearing their motors for nothing.</p><p>If you have searched for “WD Red not spinning down” or “OpenMediaVault spindown not working”, you know this is not rare. <a href="https://github.com/openmediavault/openmediavault/issues/1892">OpenMediaVault issue #1892</a> has years of reports from people with the same problem.</p><h3>Why the disks stay awake</h3><p>When you set a <strong>Spindown time</strong> in OpenMediaVault (Storage › Disks), OMV hands that timer to the disk itself. From then on it is the disk’s job to notice it has been idle and go to sleep.</p><p>Many disks, WD Reds in particular, simply don’t. I traced every command sent to my disks: after a cold boot they went 18 minutes without a single read, write or health check, with a 10 minute timer, and still kept spinning. Yet the moment they were told to sleep, they slept straight away.</p><p>So the disks can sleep. They just won’t do it on their own.</p><h3>The fix: openmediavault-spindown</h3><p>So I wrote a plugin that does the waiting for them. It’s called <strong>openmediavault-spindown</strong>, it’s free and open source, and it is set up entirely with clicks:</p><ul><li><strong>Point and click.</strong> Open Storage › Spin down, pick a disk, click Edit and choose how long it may sit idle. No commands, no settings files.</li><li><strong>Never wakes a sleeping disk.</strong> It only watches the kernel’s activity counters, which don’t touch the disk at all.</li><li><strong>Puts the disk back to sleep after every wake-up</strong>, whether a file was read or written.</li><li><strong>Shows what is going on</strong>: for each disk, whether it is asleep or in use, how soon it will sleep, and when it last slept.</li></ul><figure><img alt="The Storage › Spin down page in OpenMediaVault, listing two WD Red hard disks set to sleep after 10 minutes, both shown as Asleep" src="https://cdn-images-1.medium.com/max/1024/1*dt66K4FTS59Qn0fYoMeUlQ.png" /><figcaption>Storage › Spin down: each hard disk, how long it may sit idle, and whether it is asleep right now</figcaption></figure><p>Disks that do sleep by themselves are not affected: they are already asleep when the plugin checks, so it does nothing.</p><h3>How it works</h3><p>Every 30 seconds a small background service reads the kernel’s count of completed reads and writes for each disk. When that count hasn’t changed for the disk’s spindown time, it sends the disk one sleep command. That command first checks the disk’s power state and does nothing if the disk is already asleep, so it can never spin a sleeping disk up.</p><p>The time you choose is stored as the disk’s normal Spindown time, the same setting OpenMediaVault already has, so both pages always agree. Health checks such as S.M.A.R.T. don’t count as use, so they don’t keep a disk awake either.</p><h3>Getting started</h3><ol><li>Download the one file, openmediavault-spindown_&lt;version&gt;_all.deb, from the <a href="https://github.com/nader-eloshaiker/omv-spindown-plugin/releases/latest">latest release</a>.</li><li>In OpenMediaVault, open System › Plugins, click Upload, choose the file, then select the plugin and click Install.</li><li>Open Storage › Spin down, select a disk, click Edit and choose “Put to sleep after”, for example 10 minutes.</li><li>Click Apply in the yellow bar at the top.</li></ol><figure><img alt="Editing a disk on the Spin down page: a Put to sleep after list set to 10 minutes, with Cancel and Save buttons" src="https://cdn-images-1.medium.com/max/1024/1*YmxEsFJH0UizR_shcny31Q.png" /><figcaption>Pick a disk, click Edit and choose how long it may sit idle. No commands needed</figcaption></figure><p>The Status column then counts down and shows “Asleep” once the disk is sleeping.</p><h3>Still awake? Something is using the disk</h3><p>The plugin can only help when nothing is reading or writing the disk. If the Status column keeps saying “In use”, look for Docker containers or apps with data on that disk, media servers scanning their libraries, computers browsing your shares, or ZFS with atime turned on. Moving busy app data to an SSD and keeping the hard disks for bulk storage makes the biggest difference.</p><p>One more thing I found along the way: clicking Apply in OpenMediaVault, or installing any plugin, wakes every hard disk for a moment, because OMV’s configuration tool scans all disks for LVM volumes each time it runs. That is normal, and the disks go back to sleep after their time.</p><h3>Common questions</h3><h4>Why won’t my hard disks spin down in OpenMediaVault?</h4><p>Either the disk ignores the timer OMV gives it, or something keeps using it. The plugin’s Status column tells the two apart: a disk that counts down and then sleeps was ignoring its timer; a disk that keeps showing “In use” is busy.</p><h4>Why do WD Red drives never go to sleep?</h4><p>Their firmware often ignores the standby timer the system sets, yet they go to sleep at once when told to. That is exactly the gap this plugin fills.</p><h4>Will it wake my disks to check on them?</h4><p>No. It never reads from the disk to see how it is doing. It only reads counters the kernel already keeps.</p><h4>Does it work with ZFS, RAID or mergerfs?</h4><p>Yes. It works on each physical disk, whatever is on it. Mine is a ZFS mirror.</p><h4>Is it bad for a disk to spin down?</h4><p>Each start wears the motor a little, and disks are rated for a set number of start/stop cycles. A few sleeps a day is fine. If a disk keeps waking every few minutes, give it a longer time, or choose Never.</p><h4>Which versions of OpenMediaVault does it support?</h4><p>OpenMediaVault 8.</p><h3>Links</h3><ul><li>Project website, with the full guide: <a href="https://nader-eloshaiker.github.io/omv-spindown-plugin/">openmediavault-spindown</a></li><li>Source code and issues: <a href="https://github.com/nader-eloshaiker/omv-spindown-plugin">GitHub</a></li><li>Download: <a href="https://github.com/nader-eloshaiker/omv-spindown-plugin/releases/latest">latest release</a></li><li>Running OMV on a QNAP? My other plugin brings back quiet fans, LEDs and buttons: <a href="https://medium.com/@nader.eloshaiker/run-openmediavault-on-your-qnap-nas-quiet-fans-working-leds-and-buttons-92e8fa514411">Run OpenMediaVault on your QNAP NAS</a></li></ul><p>If it helps your disks finally get some sleep, I’d love to hear which drives you have. And if it doesn’t, open an issue on GitHub and I’ll take a look.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=986f95cf27f3" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>