<?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 Saiful Hoque on Medium]]></title>
        <description><![CDATA[Stories by Saiful Hoque on Medium]]></description>
        <link>https://medium.com/@saiful.hoque?source=rss-d67840977d3------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*tV-h9OHlOGPokc5Z6-teCg.png</url>
            <title>Stories by Saiful Hoque on Medium</title>
            <link>https://medium.com/@saiful.hoque?source=rss-d67840977d3------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 14:58:52 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@saiful.hoque/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[How to Review AI-Generated Code Without Becoming a Vibe Coder]]></title>
            <link>https://medium.com/@saiful.hoque/how-to-review-ai-generated-code-without-becoming-a-vibe-coder-575402f6700d?source=rss-d67840977d3------2</link>
            <guid isPermaLink="false">https://medium.com/p/575402f6700d</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development-team]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai-code-review]]></category>
            <dc:creator><![CDATA[Saiful Hoque]]></dc:creator>
            <pubDate>Sat, 03 Oct 2026 10:17:57 GMT</pubDate>
            <atom:updated>2026-10-11T18:33:45.386Z</atom:updated>
            <content:encoded><![CDATA[<h3>A practical workflow for keeping your code understandable, testable, and maintainable when AI does the typing.</h3><figure><img alt="Hands opening a dark box to reveal organized, illuminated software blocks and connections." src="https://cdn-images-1.medium.com/max/1024/1*vlJ6oKSeCp7Eq7h2quul-Q.png" /></figure><p>The pull request looks reassuring. The endpoint works. The tests are green. The assistant even explains why its implementation is clean. Then a reviewer asks: “What stops one customer from opening another customer’s order?”</p><p>That question takes us somewhere a successful demo cannot. It asks whether we understand the rule the software is supposed to enforce, where that rule lives, and how we know it holds.</p><p>This is the part of AI-assisted development worth protecting. We can let a tool produce a lot of code and still own the result. But ownership takes work: reading, questioning, testing, and sometimes deleting an impressive-looking solution.</p><p>The uncomfortable warning sign is when we can keep a conversation with the assistant going, yet cannot explain the application without it.</p><h3>What makes code a black box?</h3><p>Simon Willison makes a useful distinction in <a href="https://simonwillison.net/2025/Mar/19/vibe-coding/">his essay on vibe coding</a>: using an LLM does not automatically make development vibe coding. Reviewing the output, testing it, and understanding what it does are central to responsible use.</p><p>That gives us a better question than “How much of this did AI write?”</p><p><strong>Could I investigate a failure in this code if the assistant were unavailable?</strong></p><p>You do not need to memorize every dependency or line of framework internals. You do need to understand the behavior you are changing, the boundaries it crosses, the assumptions it relies on, and the evidence supporting those assumptions.</p><p>Try describing a feature through four questions:</p><ul><li>Where does its input come from, and which parts can a user control?</li><li>What must remain true while the feature runs?</li><li>What does it change, including database records and external systems?</li><li>What happens when a dependency fails or the operation happens twice?</li></ul><p>If the answers are only available in an old chat transcript, the repository has a maintenance problem.</p><h3>The research gives us reasons to be careful</h3><p>In a <a href="https://www.anthropic.com/research/AI-assistance-coding-skills">January 2026 randomized study from Anthropic</a>, 52 mostly junior Python developers worked with an unfamiliar library. The AI-assisted group averaged 50% on a subsequent comprehension quiz; the group coding without AI averaged 67%. That is a 17-percentage-point gap. The difference in completion time was not statistically significant.</p><p>The study measured understanding shortly after a limited task. It does not establish permanent skill loss or tell us how every experienced engineer uses a modern coding agent. Its qualitative analysis also found stronger understanding among some participants who used AI for conceptual questions and explanations. Those patterns were associations, not separately randomized interventions.</p><p>Productivity evidence needs similar care. <a href="https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/">METR’s early-2025 experiment</a> found that experienced developers working in familiar open-source repositories took 19% longer with the tools studied. In its <a href="https://metr.org/blog/2026-02-24-uplift-update/">February 2026 update</a>, METR said newer results suggested improvement, but selection effects made the size of the benefit difficult to estimate.</p><p>A <a href="https://arxiv.org/abs/2302.06590">controlled Copilot study published in 2023</a> found a substantial completion-time benefit on a standardized JavaScript server task. <a href="https://github.blog/news-insights/research/does-github-copilot-improve-code-quality-heres-what-the-data-says/">GitHub’s 2024 quality experiment</a> also reported improved test outcomes and modest improvements in reviewer ratings. Both were short, controlled exercises, with vendor involvement; neither measured years of maintenance.</p><p>These findings can coexist. Tasks, tools, and participants differ. They show why “it felt faster” and “I learned it” deserve separate checks.</p><p>The workflow below is a practical synthesis of those concerns and established engineering guidance. It is not an experimentally validated cure for skill loss.</p><h3>1. Write the rule before asking for the implementation</h3><p>Consider a small order service. A signed-in customer should be able to view their own orders. Other customers’ orders should remain inaccessible.</p><p>Here is a plausible first implementation, written as simplified pseudocode:</p><pre>function getOrder(request):<br>    requireSignedInUser(request)<br>    order = orders.findById(request.params.orderId)<br>    return order</pre><p>It can pass tests for a signed-in user retrieving an existing order. It can also pass a test rejecting someone who is signed out.</p><p>The missing question is whether the signed-in person may read this particular order.</p><p><a href="https://cheatsheetseries.owasp.org/cheatsheets/Authorization_Cheat_Sheet.html">OWASP’s authorization guidance</a> distinguishes proving identity from granting access and recommends checking permissions on every request.</p><p>Before generating the endpoint, write its invariant in ordinary language:</p><blockquote><em>Every returned order must belong to the authenticated customer. The server determines customer identity from the validated session, never from a customer ID supplied in the request.</em></blockquote><p>Now there is a rule against which to judge the code.</p><p>For a different feature, the invariant might be “an invoice is charged at most once,” “a cancelled job must stop making external calls,” or “a user can only export records from an organization they are authorized to access.”</p><p>Ask the assistant to identify unclear requirements before implementing them. An unresolved business rule should become a question, rather than a guess hidden inside a helper function.</p><h3>2. Make each change small enough to explain</h3><p>AI can produce an endpoint, a cache, a queue, a migration, and a reusable abstraction in one response. Reviewing all of them together can make a simple feature unnecessarily difficult to understand.</p><p><a href="https://google.github.io/eng-practices/review/developer/small-cls.html">Google’s guidance on small changes</a> recommends self-contained changes that can be reviewed thoroughly and rolled back more easily.</p><p>For the order endpoint, start with the lookup and access rule. Include the tests that establish that behavior. Introduce caching later, if there is a demonstrated need, with a separate discussion of cache keys and access boundaries.</p><p>A useful instruction to an assistant is:</p><blockquote><em>Implement only the order lookup and ownership check. Reuse the repository’s existing session and error handling. Add focused tests. Do not introduce a dependency or refactor unrelated code. Flag any requirement you cannot establish from the repository.</em></blockquote><p>There is no magic line count. A short permissions change can require more scrutiny than a large mechanical rename. Aim for one understandable decision at a time, with enough surrounding context to evaluate it.</p><h3>3. Review behavior before the assistant’s explanation</h3><p>A confident explanation can make a questionable implementation feel settled. Give yourself a chance to form an independent view first.</p><p>Read the requirement, the changed files, and the relevant calling code. Follow an actual request from entry point to response. Then use the assistant to challenge the understanding you have formed.</p><p>For our example, trace:</p><pre>request -&gt; validated session -&gt; customer identity<br>        -&gt; customer-scoped order lookup -&gt; response</pre><p>Inspect the lookup implementation. A helper named findCustomerOrder is reassuring only if its query actually includes the authenticated customer and the requested order.</p><p>Ask concrete questions: Can a request body override the session identity? Does a background job call the service through a different path? Does an error handler accidentally return the record it was supposed to reject? If caching exists, can its key mix data belonging to different customers?</p><p><a href="https://google.github.io/eng-practices/review/reviewer/looking-for.html">Google’s code review guidance</a> covers design, functionality, complexity, tests, naming, comments, and documentation. These remain useful categories when a model produces the patch.</p><p>An AI reviewer can provide another pass. It still needs evidence. Treat “authorization looks correct” as a lead to inspect, not an approval to merge. A second model may miss the same assumption as the first; agreement does not establish correctness.</p><h3>4. Design tests from the rule, not from the generated code</h3><p>If the implementation and its tests share the same misunderstanding, a green run can preserve that misunderstanding very efficiently.</p><p>Write the important scenarios before inspecting the generated test suite. For this endpoint, the minimum behavior to investigate includes:</p><ul><li>Customer A can retrieve an order belonging to A.</li><li>Customer A cannot retrieve an order belonging to B, even with B’s valid order ID.</li><li>A signed-out request is rejected.</li><li>A client-supplied customer ID cannot change the authenticated identity.</li><li>A missing order produces the response agreed in the API contract.</li></ul><p>Use the real routing and session behavior in an integration test where practical. If the test simply mocks a repository into returning exactly what the implementation expects, it may never exercise the missing ownership filter.</p><p>A revised lookup could have this shape:</p><pre>function getOrder(request):<br>    customerId = requireValidatedSession(request).customerId<br>    order = orders.findOne(<br>        id = request.params.orderId,<br>        customerId = customerId<br>    )<br>    if order is missing:<br>        return notFound()<br>    return order</pre><p>This is a narrow illustration, not production-ready security code. Real services may have staff access, organization membership, delegated permissions, database policies, or other rules. The response for inaccessible resources also needs an explicit policy; this example uses a not-found response.</p><p>One revealing check is to temporarily remove the ownership condition in a local branch and run the relevant test. If the test still passes, it is not detecting that defect. Mutation testing can automate variations of this technique when it is worth the effort.</p><p>Passing tests support particular claims about behavior. They do not prove that every important requirement was identified. <a href="https://testing.googleblog.com/2020/08/code-coverage-best-practices.html">Google’s coverage guidance</a> makes a related point: executing a line is different from checking that it behaves correctly. Use coverage to find gaps, then inspect what the assertions establish.</p><h3>5. Keep complexity within the team’s understanding</h3><p>Sometimes the generated solution is correct and still a poor fit for the people maintaining it.</p><p>For a simple lookup, do we need a generic policy engine, a repository factory, and a configurable strategy registry? Maybe the application already uses those patterns. Maybe this patch introduces them because they look reusable.</p><p>Ask what requirement each layer satisfies. If nobody can point to one, simplify.</p><p>Prefer existing conventions unless there is a reason to depart from them. Check unfamiliar dependencies against their official documentation and package registry: the exact package, version, API, maintenance status, and license. Inspect changes to lockfiles and installation scripts too.</p><p>Run the project’s normal linting, type checks, tests, dependency checks, and security tools where applicable. Automated checks are useful filters; their silence is not an architectural or security review.</p><p>Also scale scrutiny to the consequences. A spacing adjustment and a database migration should not have the same review plan. Authentication, money, sensitive data, destructive operations, and irreversible schema changes deserve a reviewer who understands the domain and a clear recovery plan.</p><h3>6. Put the important explanation in the repository</h3><p>A long chat history is a difficult place for a future maintainer to discover why a decision was made.</p><p>Leave a short explanation where it belongs: a comment near a surprising constraint, a useful test name, a PR description, or a decision note for an architectural trade-off.</p><p>For example:</p><pre>// Scope the lookup by the authenticated customer.<br>// Client-supplied customer IDs must not authorize access.</pre><p><a href="https://google.github.io/eng-practices/review/reviewer/comments.html">Google’s guidance on review comments</a> recommends making complicated code clearer and warns against leaving essential explanations only in the review discussion.</p><p>The PR description should help another person find the reasoning and verify it. “AI generated this” is provenance. It does not explain the change.</p><p>For the order endpoint, a useful description might say:</p><blockquote><em>The lookup now requires both order ID and authenticated customer ID. A cross-customer integration test checks that a valid order ID cannot expose another customer’s record. This patch does not change the schema. Reverting it would restore the access defect, so rollback alone is not a safe recovery plan.</em></blockquote><p>That last sentence matters. “We can revert” needs to be evaluated against the specific failure, particularly for security fixes and data migrations.</p><h3>7. Practise understanding while you use AI</h3><p>Before asking the assistant to fix a bug, write down your prediction: what is failing, which boundary is involved, and what observation would distinguish your theory from an alternative.</p><p>Then inspect a stack trace, query, debugger session, or relevant log. Use AI to suggest competing explanations or explain a concept you have encountered. Compare its claims with the code and official documentation.</p><p>For learning a new library, ask for a hint before a complete implementation. Explain the solution back in your own words. Change one condition and predict what happens before running it.</p><p>Keep some time for reading and debugging without generated answers. This is a practical habit, not a claim that every programmer needs an arbitrary quota of manual coding.</p><p>The aim is to remain capable of evaluating the help you receive. Repeatedly pasting an error into a chat until it disappears gives you less information than identifying why the last change fixed it.</p><h3>8. Keep reviewing after the merge</h3><p>Code ownership continues when a feature reaches production.</p><p>For a meaningful service change, decide how you would notice failure: error rates, latency, a relevant business outcome, or an authorization regression. Add observability that helps answer those questions without logging secrets or sensitive payloads.</p><p>Give the feature an owner. Keep dependencies current. When a bug is fixed, preserve the smallest useful regression test and update any explanation invalidated by the fix.</p><p>Periodically choose a critical path and explain it to a teammate. Where does it begin? Which checks protect it? What happens if a dependency times out? What evidence would help during an incident?</p><p>When understanding lives with one person, pair with someone else. When it lives only with the assistant, schedule the work required to recover it. More generated features will not resolve that gap.</p><p>For a prototype growing into a real product, make the transition explicit. Review the architecture and data flows, replace unsafe shortcuts, establish tests for critical rules, and assign maintenance responsibility before people depend on it.</p><h3>A code ownership checklist before you merge</h3><figure><img alt="Six-step AI-assisted code review workflow: define the rule, generate a small change, trace behavior, challenge with tests, explain and simplify, and own it after merge." src="https://cdn-images-1.medium.com/max/1024/1*8xqo62yOFT-DNH8uQ1cT2w.png" /><figcaption>Review workflow diagram created for this article with AI assistance.</figcaption></figure><p>Use this as a conversation starter, with more depth for higher-risk changes:</p><ul><li>I can state the requirement and its important invariants.</li><li>I have traced the changed behavior through its real callers and dependencies.</li><li>I can explain the important branches, side effects, and failure paths.</li><li>The tests check the requirement, including plausible misuse and boundary cases.</li><li>I have verified unfamiliar APIs and dependencies against primary documentation.</li><li>The implementation fits our conventions, or the departure has a clear reason.</li><li>Relevant automated checks ran, and a qualified human reviewed consequential changes.</li><li>The repository records the decisions a future maintainer will need.</li><li>We know who owns the feature, how to detect failure, and how to recover safely.</li></ul><p>If you cannot explain an important part, shrink the patch, investigate it, or ask someone with the right expertise. Rewriting a confusing section may be cheaper than carrying it into production.</p><p>AI can make the typing almost disappear. The question at the end of a review is still very ordinary: when this breaks, will we know where to look and why?</p><p>Being able to answer is what makes the code ours.</p><p>#AIAssistedCoding #CodeReview #SoftwareEngineering #VibeCoding #CodeMaintenance</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=575402f6700d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Hermes Agent Just Got a Major Upgrade — and It’s Solving Problems I Didn’t Know I Had]]></title>
            <link>https://medium.com/@saiful.hoque/hermes-agent-just-got-a-major-upgrade-and-its-solving-problems-i-didn-t-know-i-had-fd81f5693ef5?source=rss-d67840977d3------2</link>
            <guid isPermaLink="false">https://medium.com/p/fd81f5693ef5</guid>
            <dc:creator><![CDATA[Saiful Hoque]]></dc:creator>
            <pubDate>Thu, 21 May 2026 09:28:33 GMT</pubDate>
            <atom:updated>2026-05-21T09:59:59.424Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/887/1*f-EDwmOkcr1IC21Cp4rhXg.png" /></figure><p><em>The open-source AI agent that runs everywhere just shipped a wave of updates. Here’s what actually changed and why it matters.</em></p><p>Let me be straight with you: I’ve been burned by “game-changing AI tool” articles before. So when I say Hermes Agent has quietly become the most useful thing running on my machine right now, I mean it in the most boring, practical sense possible. Not because it’s impressive in demos — because it’s the thing I actually reach for.</p><p>Here’s what changed and why it matters.</p><p><strong>The Skills Hub Is Now Actually Useful</strong></p><p>For a while, Hermes had this “skills” system that felt more like a gimmick than a feature. You could save workflows, sure — but discovering and installing them was clunky.</p><p>That’s been fixed. There’s now a proper browsable hub, deduplication so you don’t end up with the same skill installed three times from different sources, and — this is the one I use constantly — you can install any skill directly from a GitHub URL.</p><p>I installed Andrej Karpathy’s coding guidelines as a Hermes skill in about 10 seconds:</p><pre>hermes skills install https://github.com/multica-ai/andrej-karpathy-skills/raw/main/skills/karpathy-guidelines/SKILL.md</pre><p>Now every coding session I run through Hermes follows Karpathy’s principles automatically: don’t overcomplicate; make surgical edits; state assumptions before writing a single line. It’s the kind of thing you’d normally have to remind an AI about in every session. Now I don’t.</p><p><strong>Your Conversations Are No Longer Split Across Two Places</strong></p><p>This one’s less exciting to talk about but genuinely changes how reliable Hermes feels day-to-day.</p><p>Previously, session data lived in two places: a SQLite database and JSONL flat files, kept in sync. Which sounds fine until they drift or you’re trying to search a past conversation and get half the results you expected.</p><p>📨 send_message: “to discord:Knightmare-dev / #general …”</p><p>That’s gone. SQLite is now the single source of truth. Full-text search across every conversation you’ve ever had, platform message IDs that actually persist correctly across Discord and other platforms, and none of the weird edge cases that came from the dual-write system.</p><p>It’s one of those changes that you only notice because things stop breaking.</p><p><strong>The Telegram menu stopped annoying me.</strong></p><p>Small thing. Real improvement. If you’re running Hermes as a Telegram bot, you know the pain: the command menu was ordered by… something. Not by what you actually use. So /new session and /model were buried under admin commands you touch maybe once a month. They fixed the ordering. Everyday commands are at the top now. I know that sounds trivial. It’s not when you’re using a bot dozens of times a day.</p><p><strong>Search Results Now Tell You When They’re Degraded</strong></p><p>The X/Twitter search tool used to fail silently. Twitter’s API would return partial or low-quality results, and you’d get something back that looked complete but wasn’t. No warning, no signal — just quietly wrong data.</p><p>Now it flags degraded results and validates dates before surfacing them. If you’re running any kind of automated news digest or trend-tracking through Hermes, this is a meaningful reliability upgrade. You’re no longer flying blind on data quality.</p><p><strong>Linux/Wayland Users: Your Clipboard Works Now</strong></p><p>Niche, but if you’re affected, you know how maddening this was. The /copy command was silently doing nothing on Wayland. It’s now wired up to wl-copy, with xclip as the fallback for X11. Works the way you’d expect.</p><p><strong>Multi-Agent Workflows Got More Stable</strong></p><p>For anyone running parallel agent workers through Hermes’s Kanban system — tasks split across multiple agent profiles, running simultaneously — there was a race condition in the gateway that could corrupt state during provider cleanup.</p><p>It’s been hardened. If you’ve been running complex multi-agent setups and occasionally seeing weird state issues, this is probably what was causing it.</p><p><strong>What Makes Hermes Worth Using at All</strong></p><p>I’ve tried most of the major AI agent tools at this point. Cursor, Copilot, Claude Code, and various wrappers. They’re all good at something. Here’s what Hermes does that the others don’t, in plain terms:</p><p>🔁 It works everywhere. Same agent — Telegram, Discord, Slack, WhatsApp, your terminal. Not a stripped-down version. The whole thing.</p><p>🔀 It runs on any model. OpenRouter, Anthropic, Copilot, Gemini, DeepSeek, local models — swap them without changing your workflow.</p><p>🧠 It remembers things. Not just in-session. Across sessions. It knows your preferences, your project conventions, and your environment. You stop re-explaining yourself.</p><p>⏰ It runs on a schedule. Daily AI briefings, GitHub trending summaries, automated reports — all delivered to wherever you want them, without you being present.</p><p>📈 It gets better the more you use it. When it solves something hard, it saves that approach as a skill and uses it again.</p><p><strong>Getting Started</strong></p><pre>curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash<br>hermes setup</pre><p>Docs: <a href="https://hermes-agent.nousresearch.com/docs">https://hermes-agent.nousresearch.com/docs</a></p><p>GitHub: <a href="https://github.com/NousResearch/hermes-agent">https://github.com/NousResearch/hermes-agent</a></p><p>If you’re already using it, update now. If you’re not, this is probably the version that’s worth your time to try.</p><p><em>Tags: AI Agents · Developer Tools · Open Source · Productivity · Artificial Intelligence · Hermes Agent</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fd81f5693ef5" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>