<?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[CodeX - Medium]]></title>
        <description><![CDATA[Everything connected with Tech &amp; Code. Follow to join our 1M+ monthly readers - Medium]]></description>
        <link>https://medium.com/codex?source=rss----29038077e4c6---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>CodeX - Medium</title>
            <link>https://medium.com/codex?source=rss----29038077e4c6---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 01:43:11 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/codex" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com" rel="hub"/>
        <item>
            <title><![CDATA[The Era of Super Agents: Is It Really the Truth? Let’s Find Out.]]></title>
            <link>https://medium.com/codex/the-era-of-super-agents-is-it-really-the-truth-lets-find-out-f8ee80759ac4?source=rss----29038077e4c6---4</link>
            <guid isPermaLink="false">https://medium.com/p/f8ee80759ac4</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[deepseek]]></category>
            <dc:creator><![CDATA[Praveen Gautam]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 21:31:01 GMT</pubDate>
            <atom:updated>2026-11-16T21:31:01.643Z</atom:updated>
            <content:encoded><![CDATA[<p>A systems engineering breakdown of event pipelines, worker isolation, and the real cost of multi-agent orchestration.⁠</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BvIrQDdDveQHBtbtQ7SIwA@2x.jpeg" /><figcaption><em>Image created by author.</em></figcaption></figure><p>If you spend any time browsing tech communities — whether it’s Reddit, developer forums, YouTube, or even Instagram — you’ve likely run into a wave of breathless hype. The narrative is everywhere: <em>“DeepSeek has launched a super agent!”</em>, <em>“The era of autonomous super agents is finally here!”</em>, <em>“AI is about to replace developers overnight!”</em></p><p>It sounds like science fiction. Has DeepSeek somehow unlocked a breakthrough in raw model intelligence? Have they built an AI that finally thinks, reasons, and acts with superhuman capability in a way no one else has managed?</p><p>To find out, let’s look past the marketing buzzword and dive into what’s actually under the hood.</p><h3>The Reality Behind the “Super Agent”</h3><p>To be completely honest, the origin story of this project is much more grounded than the hype suggests. It likely started the way many great engineering projects start: an engineer looked at standard Large Language Models, recognized their limitations in open-ended environments, and asked, <em>“What if I build a pipeline or an agent factory around this LLM to see what happens?”</em></p><p>They experimented, ran some initial trials, saw promising results, and eventually, it was published as DeepSeek’s ⁠dsh-superagent-prototype⁠ and an article on wechat.</p><p>But let’s be clear: <strong>this is not a “super agent” in the sense of a sudden, magical leap in AI capability.</strong></p><p>The underlying LLM is fundamentally the same. It’s still relying on standard model calls through APIs or harnesses. What has actually changed — and what makes this project genuinely interesting — isn’t the intelligence of the model itself. <strong>It’s the systems engineering wrapped around it.</strong></p><h3>Automating the Everyday Developer Workflow</h3><p>To understand what this prototype actually does, think about how a human software engineer operates in a modern corporate environment.</p><p>1. <strong>The Signal:</strong> Work comes in from various sources — a GitHub pull request, a Jira ticket, a message, or an urgent bug report.</p><p>2. <strong>The Tracking:</strong> Before diving in, a ticket is typically created to track the scope and maintain a record.</p><p>3. <strong>The Interaction:</strong> The developer opens up an AI chat window. They feed the context into the agent: <em>“Analyze this error,”</em> or <em>“How should we solve this?”</em> They go back and forth — refining prompts, checking code snippets, and iterating until a solution takes shape.</p><p>4. <strong>The Execution &amp; Review:</strong> Once the solution is clear, they test it, check with teammates if the problem is complex, complete the task, and raise a pull request.</p><p>That is the standard lifecycle of software development today.</p><p>And what did DeepSeek’s prototype do? <strong>It took this exact human workflow and translated it into an automated software pipeline.</strong></p><h3>Inside the Pipeline: How the Architecture Actually Works</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KarCLgccFSaX0xmg7dpV1Q@2x.jpeg" /><figcaption><em>Diagram created by author based on DeepSeek’s open-source prototype architecture.</em></figcaption></figure><p>Instead of a human manually reviewing issues and chatting back and forth with an LLM in a window, the system establishes a robust architectural loop:</p><blockquote><strong>Event Ingestion &amp; Queuing:</strong> The system listens to incoming events from GitHub, Jira, and messaging platforms like Feishu, maintaining a centralized event queue.</blockquote><blockquote><strong>The Router (Coordinator):</strong> Sitting at the front of the queue is a router agent. Guided by a rule/policy engine, it classifies whether an event is doable, evaluates its complexity, and decides how to route it.</blockquote><blockquote><strong>Worker Allocation &amp; Isolation:</strong> Once a supervisor reviews the task, it assigns it to a dedicated worker. The worker accepts the task, creates an isolated git worktree / worker session, and starts executing. If it encounters a complex blocker, it can loop back to the router or request a more capable model.</blockquote><blockquote><strong>State &amp; Persistence:</strong> Every single action, log, state change, and message receipt is tracked in a local SQLite database. The pipeline also manages supporting elements like settings, loopback management, and health sessions.</blockquote><p>Once the worker completes its job — coding, testing, or drafting a reply — the result moves to human review, where a PR can be raised or a response posted.</p><p>While it feels futuristic to have a 24/7 background system queuing and processing tasks, everything you see here is a product of <strong>super engineering around standard agents</strong>, rather than a fundamental upgrade to the agent’s innate intelligence. It’s currently in an experimental, testing phase, and its real-world efficiency is far from proven.</p><h3>The Numbers DeepSeek Actually Published — And Why They Prove My Point</h3><p>So why did DeepSeek build this at all?</p><p>Because of one simple observation from their paper:<strong> a person can usually follow only 3 to 5 active agent sessions at once.</strong></p><p>The bottleneck is no longer the model. It’s your attention.</p><p>To prove their design works, DeepSeek ran their own simulation: ∼300 messages per run, ∼20 real work requests, 5 runs per configuration.</p><p>Here are their numbers:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hUNKVH23Srgp9jDDbEEE-Q.png" /><figcaption><em>Chart created by author based on DeepSeek experimental simulation data.</em></figcaption></figure><p>On paper, it looks impressive. 1.9x faster.</p><p>But read the fine print, because this is where the hype falls apart:</p><ol><li>This is DeepSeek’s own test, not an independent benchmark. No SWE-bench, no Terminal-Bench, no third-party verification.</li><li>Coding was simulated. The agent never wrote real code in the test. A tool just consumed time to pretend it was coding.</li><li>It’s 2–3x more expensive. To get that 1.9x speedup, the Super-agent burned 23.23M cache-read tokens vs 6.05M to 10.82M for a single session.</li></ol><p>That last point is the real story.</p><p>It’s not that DeepSeek built a smarter model. It’s that they built a more expensive orchestration pipeline that trades tokens for speed — and trades your attention for automation.</p><p>Faster, yes. Smarter, no. Cheaper, definitely not.</p><h3>Is It Really a “Super Agent”? The Critical Risks</h3><p>If we look at the claim objectively, can we call this a true super agent?</p><p>In one sense, yes — having a 24/7 automated supervisor continuously queuing, reviewing, and executing tasks feels like having an autonomous workforce. But when you look closely at how it operates under pressure, several major red flags emerge:</p><p>1. <strong>The Illusion of Security:</strong> LLMs hallucinate. If an agent is running locally and struggles with server authentication during testing, it might dynamically decide to disable security checks or bypass authentication entirely to make things work. Without strict, hard-coded guardrails, true security is hard to guarantee.</p><p>2. <strong>Model Judgment &amp; Misinterpretation:</strong> The success of the pipeline entirely depends on the quality of the model you plug into it. Different models yield drastically different judgments, making the system prone to prompt misunderstandings and internal logic gaps.</p><p>3. <strong>Infrastructure and API Costs:</strong> Running multiple concurrent agent sessions locally requires a powerful machine. If deployed on the cloud, your API usage bills will scale rapidly. Furthermore, relying on a single SQLite database for multiple concurrent agents quickly leads to connection congestion.</p><p>4. <strong>Tight Coupling:</strong> This architecture is tightly coupled with DeepSeek Harness. You cannot simply drop this pipeline into any arbitrary agent harness without significant friction.</p><h3>The Final Verdict</h3><p>So, is it production-ready? <strong>No.</strong></p><p>Is it a revolutionary “super agent”? <strong>No.</strong></p><p>Is it a brilliant, well-engineered side project to study orchestration patterns? <strong>Definitely yes.</strong></p><p>At the end of the day, DeepSeek’s prototype reminds us that the next frontier of AI isn’t just about making smarter models — it’s about building smarter engineering pipelines around the models we already have.</p><h3>References &amp; Further Reading</h3><ol><li>DeepSeek AI. <a href="https://github.com/deepseek-ai/dsh-superagent-prototype">dsh-superagent-prototype GitHub Repository</a> — The public research prototype codebase, setup guides, and internal architectural design documents.</li></ol><p>Enjoyed this article? Follow me for more practical insights on software engineering, system design, and AI.</p><p>And don’t forget to let me know your thoughts in the comments.</p><p>Thanks for reading! 👋</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f8ee80759ac4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codex/the-era-of-super-agents-is-it-really-the-truth-lets-find-out-f8ee80759ac4">The Era of Super Agents: Is It Really the Truth? Let’s Find Out.</a> was originally published in <a href="https://medium.com/codex">CodeX</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What 3 Years of Using AI Agents in Corporate Codebases Taught Me]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/codex/what-3-years-of-using-ai-agents-in-corporate-codebases-taught-me-dbe82f397fbe?source=rss----29038077e4c6---4"><img src="https://cdn-images-1.medium.com/max/717/1*o7r8cLp7k4YPgqJ1Z99vlg.jpeg" width="717"></a></p><p class="medium-feed-snippet">The agent pushed my code to git. I hadn&#x2019;t asked it to. I was still reading the diff, half sure about one function, and it had already run&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/codex/what-3-years-of-using-ai-agents-in-corporate-codebases-taught-me-dbe82f397fbe?source=rss----29038077e4c6---4">Continue reading on CodeX »</a></p></div>]]></description>
            <link>https://medium.com/codex/what-3-years-of-using-ai-agents-in-corporate-codebases-taught-me-dbe82f397fbe?source=rss----29038077e4c6---4</link>
            <guid isPermaLink="false">https://medium.com/p/dbe82f397fbe</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[llm]]></category>
            <dc:creator><![CDATA[MayhemCode]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 13:21:07 GMT</pubDate>
            <atom:updated>2026-11-16T13:21:06.652Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[My camera app wrote its own benchmark result before the benchmark ran]]></title>
            <link>https://medium.com/codex/my-camera-app-wrote-its-own-benchmark-result-before-the-benchmark-ran-6144adba8b05?source=rss----29038077e4c6---4</link>
            <guid isPermaLink="false">https://medium.com/p/6144adba8b05</guid>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Muhammad Azhar]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 13:18:48 GMT</pubDate>
            <atom:updated>2026-11-16T13:18:46.982Z</atom:updated>
            <content:encoded><![CDATA[<h4>A shortcut meant for the emulator put guessed timings into eight releases of CinematiQ. When a Galaxy A50 was finally measured, its face mesh took 61 ms where the guess said 35.</h4><p>Early on 15 November the Galaxy A50 I test on failed a check I had assumed it passed weeks ago. CinematiQ Pro, my camera app, decides how much of its Beauty filter a phone can run by timing it on that phone. On the A50 the face mesh took a median of 61.16 ms against a 50 ms limit, and the CORE render’s 95th percentile came in at 14.32 ms against 14. So the A50 drops to ESSENTIAL, the lighter graph.</p><figure><img alt="Two bar charts. Left: face mesh median, the startup seed said 35 ms, the CORE limit is 50 ms, the Galaxy A50 measured 61.16 ms. Right: CORE render at half scale, 95th percentile, the limit is 14 ms, one earlier run showed 10.93 ms and the sustained run measured 14.32 ms. Both measured bars are over their limits, so the A50 runs ESSENTIAL." src="https://cdn-images-1.medium.com/max/1024/1*aT4VcD9pWAqKaYOp2xpfgQ.png" /><figcaption>The Galaxy A50’s sustained run against CinematiQ’s CORE gates, next to the 35 ms the startup seed had already saved for the mesh.</figcaption></figure><p>What bothered me is that the eight releases before this one would most likely never have run that measurement on the A50 at all. They already had a number for it, and nobody had measured it.</p><h3>Where the number came from</h3><p>On 13 September a change went in so the tier ladder could reach something above ESSENTIAL on an emulator, which has no real phone hardware to time. It added a set of synthetic stage costs and a step at startup: if the cache held no measurement for this app version and camera, pick defaults by device profile and save them. A phone with no hard demotion got defaultCore, which says the face mesh costs 35 ms. The commit message is plain about it: &quot;The numbers in defaultFlagship are stand-ins, not measurements from hardware.&quot;</p><p>Nothing limited that step to the emulator. It ran on every phone.</p><p>The real benchmark sat in a separate block that waited for a working camera preview, and its first check was whether that same cache already held a measurement. If it did, it returned. The startup step only needed the device report, so it normally got there first. On a phone like the A50 the guess was in the cache before the benchmark looked, and the benchmark saw a full cache and stopped.</p><figure><img alt="A sequence diagram in two rows. Top row, releases 1.0.6 to 1.0.13: the device report is ready, startup saves the seeded costs to the cache, the preview starts, the benchmark finds the cache full and returns without measuring. Bottom row, 1.0.14: the cost stays unknown and the phone runs ESSENTIAL, the first preview frame starts the probes on the real renderer, a failed probe stays unmeasured, and the tier comes only from measured numbers." src="https://cdn-images-1.medium.com/max/1024/1*HS8dtERLU5rXjhfJ4IkoHA.png" /><figcaption>Startup and the benchmark in releases 1.0.6 to 1.0.13, and in 1.0.14. Read off MainActivity.kt at the two release tags.</figcaption></figure><p>I can’t show you a device log of that happening on someone’s phone. I’m reading it off the code: the save, the cache key both blocks used (app version, benchmark hash, camera id) and the early return. Because the key included the app version, every update emptied the cache and the next launch seeded it again. Eight tagged release builds carried it, from 1.0.6 on 30 September to 1.0.13 on 9 November.</p><figure><img alt="A timeline from 13 September to 15 November 2026. The seed commit on 13 September, then eight release tags carrying it: 1.0.6 on 30 September, 1.0.7 on 4 October, 1.0.8 on 9 October, 1.0.9 on 17 October, 1.0.10 and 1.0.11 on 18 October, 1.0.12 on 5 November and 1.0.13 on 9 November. The fix ships in 1.0.14 on 15 November." src="https://cdn-images-1.medium.com/max/1024/1*SizYbERrJPEFidYqWcGvHw.png" /><figcaption>Every tagged CinematiQ release between the 13 September seed commit and the 15 November fix, from git tags.</figcaption></figure><h3>The benchmark had a shortcut of its own</h3><p>The fix found a second one. When the real Beauty graph failed inside the benchmark, the code caught the error, drew a simpler stand-in shader instead and recorded that time as the graph’s. A phone that couldn’t run the graph at all could come out of the benchmark looking fast.</p><p>There was a quieter mismatch too. At 0.67 and 0.75 processing scale the benchmark timed CORE_LOW_FUSED_V1, while the live CORE renderer runs the guided filter path. It was timing a graph the user never sees.</p><p>1.0.14 changes all three. Startup leaves the measurement unknown until the worker finishes, and the phone runs ESSENTIAL meanwhile. A failed probe stays unmeasured instead of borrowing another shader’s time. The 0.67 and 0.75 probes now use the graph CORE actually renders, and CORE at 0.5 has its own measurement. The benchmark hash moved from live-beauty-graph-v1 to live-beauty-fast-guided-gpu-mesh-v4, so every cached number from an older build, seeded or not, is ignored after the update.</p><h3>Then the A50 ran it for real</h3><p>The first honest run failed before it measured anything. The benchmark times its passes on a synthetic face image, and that image was a PNG. The build drops every PNG from assets, a rule added so the app’s AR textures, which moved to lossless WebP, wouldn’t ship twice. It took the benchmark’s only test image with them. The fixture is a lossless WebP now and decodes to the same RGB bytes. The detector probes also got three warmup runs before their five measured samples, so a cold start isn’t what gets recorded.</p><p>Then came the numbers in the chart above. One earlier run had shown 10.93 ms for the render, which is the kind of number I’d have been glad to believe. A single run doesn’t say what the phone does once it’s warm and busy, and the sustained run said 14.32. Raising the worker’s priority didn’t bring the mesh down either.</p><p>So the A50 gets ESSENTIAL. I approved sending 1.0.14 to Play’s production review on 15 November with that result left as it is, and the gates stay at 50 and 14. Lowering them until the A50 passes would only be writing a new guess into the code.</p><p>What I can’t tell you is how many phones in the field ran CORE on the guess. I haven’t found a way to see that from here, and the A50 is the only phone the new benchmark has been run on so far.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6144adba8b05" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codex/my-camera-app-wrote-its-own-benchmark-result-before-the-benchmark-ran-6144adba8b05">My camera app wrote its own benchmark result before the benchmark ran</a> was originally published in <a href="https://medium.com/codex">CodeX</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CVE-2026–6460 (CVSS 8.8): The PostgreSQL RCE Flaw That Hid for 22 Years and How to Patch It]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/codex/cve-2026-6460-cvss-8-8-the-postgresql-rce-flaw-that-hid-for-22-years-and-how-to-patch-it-63d7b419a22c?source=rss----29038077e4c6---4"><img src="https://cdn-images-1.medium.com/max/1672/1*OKqVMpgEndrS1q1Jk9Y6pA.png" width="1672"></a></p><p class="medium-feed-snippet">PostgreSQL just fixed 52 security vulnerabilities in one release. Here is what the headline bug actually does, who is at risk, and what to&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/codex/cve-2026-6460-cvss-8-8-the-postgresql-rce-flaw-that-hid-for-22-years-and-how-to-patch-it-63d7b419a22c?source=rss----29038077e4c6---4">Continue reading on CodeX »</a></p></div>]]></description>
            <link>https://medium.com/codex/cve-2026-6460-cvss-8-8-the-postgresql-rce-flaw-that-hid-for-22-years-and-how-to-patch-it-63d7b419a22c?source=rss----29038077e4c6---4</link>
            <guid isPermaLink="false">https://medium.com/p/63d7b419a22c</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[postgresql]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[database]]></category>
            <dc:creator><![CDATA[Developer Awam]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 13:18:45 GMT</pubDate>
            <atom:updated>2026-11-16T13:18:44.107Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[10 Codebase Red Flags That aren’t actually Red Flags]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/codex/10-codebase-red-flags-that-arent-actually-red-flags-e5890544f7a4?source=rss----29038077e4c6---4"><img src="https://cdn-images-1.medium.com/max/2600/0*QrTZzwH3vhWmLE4l" width="6000"></a></p><p class="medium-feed-snippet">Why some of the things developers criticize most are perfectly reasonable engineering decisions</p><p class="medium-feed-link"><a href="https://medium.com/codex/10-codebase-red-flags-that-arent-actually-red-flags-e5890544f7a4?source=rss----29038077e4c6---4">Continue reading on CodeX »</a></p></div>]]></description>
            <link>https://medium.com/codex/10-codebase-red-flags-that-arent-actually-red-flags-e5890544f7a4?source=rss----29038077e4c6---4</link>
            <guid isPermaLink="false">https://medium.com/p/e5890544f7a4</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[writing]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Yaninyz witty]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 13:18:42 GMT</pubDate>
            <atom:updated>2026-11-16T13:18:41.697Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Android 12 answered my app’s own permission check as the shell, and androidx crashed on it]]></title>
            <link>https://medium.com/codex/android-12-answered-my-apps-own-permission-check-as-the-shell-and-androidx-crashed-on-it-1f973397f452?source=rss----29038077e4c6---4</link>
            <guid isPermaLink="false">https://medium.com/p/1f973397f452</guid>
            <category><![CDATA[android]]></category>
            <category><![CDATA[android-development]]></category>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[aosp]]></category>
            <dc:creator><![CDATA[Muhammad Azhar]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 13:18:25 GMT</pubDate>
            <atom:updated>2026-11-16T13:18:23.827Z</atom:updated>
            <content:encoded><![CDATA[<h4>My ADB app borrows the shell’s permission identity for its helper. Below API 33, ContextCompat.registerReceiver checks a permission the shell can never hold.</h4><p>ADB Nexus 1.0.49, tagged on 24 October, crashed on Android 12 in a line I’d have called boring. UsbHostController, the class that watches for USB devices being plugged in and out, registers one broadcast receiver when it&#39;s built, through ContextCompat.registerReceiver with RECEIVER_NOT_EXPORTED. That call fell over.</p><p>On Android 12 the call can throw in exactly one way. This is the message, from the androidx core 1.13.1 class the app ships:</p><pre>Permission com.metacyber.adbnexus.DYNAMIC_RECEIVER_NOT_EXPORTED_PERMISSION is required by your application to receive broadcasts, please add it to your manifest</pre><p>The manifest wasn’t the problem. androidx core adds that permission to every app that uses it, with protectionLevel=&quot;signature&quot;, and the aapt dump of my release manifest has the declaration at line 154 and the uses-permission at line 158. My app holds it, most of the time.</p><figure><img alt="Flow diagram in seven boxes. UsbHostController calls ContextCompat.registerReceiver with RECEIVER_NOT_EXPORTED. On API 26 to 32 androidx checks whether the app holds its own DYNAMIC_RECEIVER_NOT_EXPORTED_PERMISSION. Android 12&#39;s ShellDelegate sees the delegated uid and a null permission list, so it answers as the shell, which cannot hold the app&#39;s signature permission. The check is denied and androidx throws a RuntimeException. A side box notes the helper adopted shell identity." src="https://cdn-images-1.medium.com/max/1024/1*rMZ3Or7oy1uNoyfVXAj4Rg.png" /><figcaption>The path from one receiver registration to the crash, read from androidx core and Android 12’s source. It needs the helper to be holding shell identity.</figcaption></figure><h3>The part of this app that isn’t normal</h3><p>ADB Nexus is an ADB client, and on Android 12 and later it can connect to its own phone. Once it has that connection it starts an instrumentation inside its own process from the shell, and the helper running there (line 168 of InAppHelperInstrumentation.kt) calls UiAutomation.adoptShellPermissionIdentity() with no arguments. While that&#39;s held, my process can do what the shell can do. That&#39;s the whole reason the helper exists.</p><p>What I hadn’t read was how Android answers permission questions during that window. In android12-release, PermissionManagerService installs a ShellDelegate, and its checkUidPermission does this: if the uid asking is the delegated uid, and the permission is one of the delegated ones, check it as Process.SHELL_UID instead. The method that decides which permissions count has a one-line comment above its return: &quot;null permissions means all permissions are targeted&quot;.</p><p>No arguments is null. So for as long as the helper holds shell identity, every permission check for my uid gets the shell’s answer, including checks for my own app’s permissions. The shell is com.android.shell, signed with the platform key. It can&#39;t hold a signature permission defined by an app signed with mine.</p><p>Below API 33 there’s no platform flag for a receiver other apps can’t reach, so androidx fakes one. It registers the receiver behind that signature permission, and before it does, obtainAndCheckReceiverPermission asks PermissionChecker.checkSelfPermission whether the app holds it. From Android 10 on it asks a second time under the op package name, which is the same package here, and then it throws.</p><figure><img alt="Two code panels. Left, androidx obtainAndCheckReceiverPermission checks the app&#39;s DYNAMIC_RECEIVER_NOT_EXPORTED_PERMISSION with PermissionChecker.checkSelfPermission and throws a RuntimeException if it is not granted. Right, Android 12&#39;s ShellDelegate.checkUidPermission answers for Process.SHELL_UID when the uid is the delegated one, and isDelegatedPermission carries the comment that null permissions means all permissions are targeted." src="https://cdn-images-1.medium.com/max/1024/1*839cWiO3qM1cAsig17ahCg.png" /><figcaption>Shortened excerpts of the two checks. androidx asks whether my app holds its own permission; Android 12 answers that question as the shell.</figcaption></figure><h3>Why only Android 12 and 12L</h3><p>Two version gates line up. The helper returns early on anything below Build.VERSION_CODES.S, so nothing older ever holds shell identity. And from API 33, ContextCompat passes the flag straight to the platform&#39;s own registerReceiver and checks nothing. That leaves API 31 and 32, with the helper connected. Every crash this path can produce sits in that one cell.</p><figure><img alt="A grid with three columns, API 26 to 30, API 31 and 32, and API 33 and later, and two rows, helper off and helper holding shell identity. Five cells are safe: androidx grants the permission, the platform flag is used, or the helper cannot run. The one red cell, API 31 and 32 with the helper connected, reads checked as shell, denied, RuntimeException in 1.0.49, and RECEIVER_EXPORTED instead in 1.0.52." src="https://cdn-images-1.medium.com/max/1024/1*JT71m1sOoziLWj3zmNw7gw.png" /><figcaption>Six combinations of Android version and helper state. Only API 31 and 32 with the helper connected reached the throw.</figcaption></figure><h3>The fix, and what it gives up</h3><p>The fix went into commit 36dea84a9 on 9 November and is in 1.0.52. A 45-line file, AppReceivers.kt, adds registerAppReceiver, which asks androidx&#39;s own question first: below API 33 it calls PermissionChecker.checkSelfPermission on the same permission name. Granted, and it uses RECEIVER_NOT_EXPORTED as before. Denied, which only happens while the shell&#39;s identity is borrowed, and it registers with RECEIVER_EXPORTED. Below 33 the platform ignores that flag, so this is a plain registration with no permission attached. All three receivers that went through ContextCompat now go through this function: USB, the Wi-Fi scan and a battery probe. A 30-line unit test checks that API 33 and 36 always take the platform flag, that API 31 takes the androidx path only when the permission is granted, and that the permission name matches the string androidx builds.</p><p>It isn’t free. In that window on those two versions, any app on the phone can send the USB receiver a broadcast. Two of the three actions it listens for, USB_DEVICE_ATTACHED and USB_DEVICE_DETACHED, are protected broadcasts in Android 12&#39;s own manifest, and only the system can send them. The third is my own com.metacyber.adbnexus.USB_PERMISSION, and nothing protects that. The receiver does the same thing for all three: it re-reads the device list from UsbManager. A spoofed broadcast buys an attacker one extra re-read. I&#39;ll take that over a crash.</p><p>There’s a cleaner fix I haven’t made. adoptShellPermissionIdentity also takes a list of permission names, and with a list the delegate leaves every other check with my own uid. The cost is writing down every permission the helper borrows from the shell, and a name left off that list would fail somewhere inside the helper instead of here, which is a harder thing to see in Crashlytics.</p><p>The same two pieces of source apply to anything that calls adoptShellPermissionIdentity() with no arguments on API 31 or 32, instrumentation tests included. If a test does that and then touches code that registers a receiver through ContextCompat, it should hit the same exception. I haven&#39;t run that test. I&#39;d want to before telling anyone it&#39;s certain.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1f973397f452" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codex/android-12-answered-my-apps-own-permission-check-as-the-shell-and-androidx-crashed-on-it-1f973397f452">Android 12 answered my app’s own permission check as the shell, and androidx crashed on it</a> was originally published in <a href="https://medium.com/codex">CodeX</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CSS Can Show Form Errors Only After the User Types. Most Developers Still Track Touched State.]]></title>
            <link>https://medium.com/codex/css-can-show-form-errors-only-after-the-user-types-most-developers-still-track-touched-state-9da1fd327523?source=rss----29038077e4c6---4</link>
            <guid isPermaLink="false">https://medium.com/p/9da1fd327523</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[css]]></category>
            <category><![CDATA[html]]></category>
            <category><![CDATA[frontend-development]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Sam - Web Dev & SEO]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 13:18:20 GMT</pubDate>
            <atom:updated>2026-11-16T13:18:19.499Z</atom:updated>
            <content:encoded><![CDATA[<p><em>A required field that turns red before anyone has typed in it is the oldest complaint about CSS form validation. The usual fixes are a `touched` class added from JavaScript or a placeholder trick, and both get edge cases wrong. The `:user-invalid` and `:user-valid` pseudo-classes wait for the user, and they work in Chrome and Edge 119, Firefox 88 and Safari 16.5. I measured exactly when they match, and where the older fixes fail.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZCE4z71CMa_sWSOA80ajZw.png" /></figure><p>I want to describe a stylesheet rule that I’d guess you’ve written and then deleted.</p><p>You have a form with required fields, and you want invalid ones to show a red border:</p><pre>input:invalid {<br> border-color: red;<br>}</pre><p>I loaded a form with that rule, and the empty email field was red before I touched anything. That’s correct by the definition of `:invalid`, since an empty required field is invalid, and it’s a bad way to greet someone.</p><p>So you fixed it in JavaScript. The common version marks a field once the user has left it:</p><pre>for (const field of form.elements) {<br> field.addEventListener(&quot;blur&quot;, () =&gt; field.classList.add(&quot;touched&quot;));<br>}</pre><pre>.touched:invalid {<br> border-color: red;<br>}</pre><p>That looks right, and for the first field it is. I tested two things people do with forms.</p><p>- <strong>I clicked Send without touching any field.</strong> No field turned red. The browser moved focus to the first invalid field, but my styles had nothing to say, because nothing had been blurred yet.<br>- <strong>I typed a bad address, left the field and then pressed Reset</strong>. The field was empty again and still red. The form went back to its starting state, and the class didn’t.</p><p>The other popular fix avoids script with a placeholder trick, which needs a `placeholder` attribute on every input, even an empty-looking one:</p><pre>input:not(:placeholder-shown):invalid {<br> border-color: red;<br>}</pre><p>That one failed in four ways in my test. The email field turned red on the first keystroke, because “a” isn’t an address yet. A required field that I typed in and then cleared was not red, because the placeholder was showing again. Sending the untouched form flagged nothing. And an input with no `placeholder` attribute was red on load, which is the bug it was meant to fix.</p><p>Here is the rule that does what all of that was reaching for:</p><pre>input:user-invalid {<br> border-color: red;<br>}</pre><p>With that rule, the field was not red on load and not red while I typed “a”. It turned red when I left the field with a bad address in it. A required field that I typed in and cleared was red. Sending the untouched form turned every invalid field red, and Reset cleared them all.</p><h4>When `:user-invalid` matches</h4><p>It uses the same validity check as `:invalid`, and adds a condition: the user has to have interacted with the field. This is what I measured in Chrome 153, step by step, on a required email field:</p><p>- <strong>On load, on focus, and after focusing and leaving without typing:</strong> no match.<br>- <strong>While typing an invalid value for the first time:</strong> no match.<br>- <strong>After leaving the field with an invalid value:</strong> it matched.<br>- <strong>From then on, it updated on every keystroke.</strong> When I went back and completed the address, the field stopped matching `:user-invalid` and started matching `:user-valid` while I was still typing. Deleting characters flagged it again immediately.<br>- <strong>After a submit attempt:</strong> every invalid field matched, including ones I’d never touched.<br>- <strong>After Reset:</strong> nothing matched.</p><p>So the first error waits until you leave the field, and after that the feedback is live. That’s the behavior most hand-written validation aims for.</p><p>One honest point before the use cases. This is styling. It doesn’t replace the validation itself, which is still `required`, `type`, `minlength` and the rest of the browser’s constraint checks, and it doesn’t replace validating on the server.</p><h4>Use case 1: red and green borders</h4><pre>input:user-invalid,<br>select:user-invalid,<br>textarea:user-invalid {<br> border-color: red;<br>}<br>input:user-valid,<br>select:user-valid,<br>textarea:user-valid {<br> border-color: green;<br>}</pre><p>After I entered a valid address and left the field, the border was green, and after I broke it, red. An untouched field kept its normal border. That’s the whole “touched” feature in six selectors.</p><h4>Use case 2: an error message that appears at the right time</h4><pre>&lt;div class=&quot;field&quot;&gt;<br> &lt;label for=&quot;email&quot;&gt;Email&lt;/label&gt;<br> &lt;input id=&quot;email&quot; type=&quot;email&quot; required aria-describedby=&quot;email-error&quot;&gt;<br> &lt;p class=&quot;error&quot; id=&quot;email-error&quot;&gt;Enter a valid email address.&lt;/p&gt;<br>&lt;/div&gt;</pre><pre>.error {<br> display: none;<br>}<br>.field:has(:user-invalid) .error {<br> display: block;<br>}</pre><p>The message computed to `display: none` on load and while I typed, and to `display: block` once I left the field with a bad value. When I fixed the address, it went away again as I typed.</p><h4>Use case 3: checkboxes and selects</h4><pre>input[type=&quot;checkbox&quot;]:user-invalid,<br>select:user-invalid {<br> outline: 2px solid red;<br>}</pre><p>These don’t wait for you to leave the control. A required checkbox that I checked and then unchecked matched `:user-invalid` immediately, while it still had focus. A required select did the same when I used the keyboard to pick an option and then moved back to the empty one. That makes sense, since changing a checkbox is a finished action in a way that typing one letter isn’t.</p><h4>Use case 4: a note for the whole form</h4><pre>.form-note {<br> display: none;<br>}<br>form:has(:user-invalid) .form-note {<br> display: block;<br>}</pre><p>A paragraph with that class stayed hidden until some field in the form was flagged. When I sent the untouched form, it appeared along with the red borders. This is where the submit behavior pays off, because a class-based approach needs extra code to mark every field on submit.</p><h4>Use case 5: errors that come from your server</h4><p>Some errors can’t be known in the browser, such as an address that’s already registered. `setCustomValidity()` makes a field invalid from script, and `:user-invalid` follows it:</p><pre>email.setCustomValidity(&quot;That address is already registered.&quot;);</pre><p>I typed a valid address and left the field, so it matched `:user-valid`. After that call, it matched `:user-invalid` with no further interaction. Calling `email.setCustomValidity(“”)` returned it to `:user-valid`. So one stylesheet handles both the browser’s rules and yours.</p><h4>Progressive enhancement</h4><p>Support is wide enough that I’d use this without a fallback in most projects. If you need to cover older browsers, keep the class version for them only:</p><pre>@supports not selector(:user-invalid) {<br> .touched:invalid {<br> border-color: red;<br> }<br>}</pre><p>In Chrome that rule was ignored, and a field with the `touched` class and a bad value kept its normal border. I couldn’t run a browser without `:user-invalid`, so I tested the other branch by putting a made-up pseudo-class in the condition, and then the rule applied. That tests the `<a href="http://twitter.com/supports">@supports</a>` logic and not an old browser.</p><h4>Browser support: the honest picture</h4><p>The `web-features` data, version 3.44.0, lists `:user-valid` and `:user-invalid` as supported from Chrome and Edge 119, Firefox 88 and Safari 16.5, including iOS. It marks them Baseline since November 2, 2023 and widely available since May 2, 2026. The `:has()` selector in use cases 2 and 4 is listed from Chrome and Edge 105, Firefox 121 and Safari 15.4, and widely available since June 19, 2026.</p><p>So this isn’t new. It’s a feature that reached every browser while most of us kept the workaround. I ran every example in Chrome 153, which was the only version available in my environment. Firefox and Safari support comes from the data, and the exact timing in those browsers is something I haven’t measured.</p><h4>Gotchas worth knowing before you ship</h4><p><strong>The first error appears on leaving the field.</strong> While I typed a bad address for the first time, nothing was flagged. If you want an error on the first keystroke, this won’t give it to you.</p><p><strong>Focusing and leaving an empty field doesn’t flag it.</strong> The user has to change something first. The `touched` class pattern flags that case, so the behavior differs. The empty field is flagged on a submit attempt.</p><p><strong>Values set by script don’t count.</strong> I set the field’s value from JavaScript to something invalid. It matched `:invalid` and not `:user-invalid`, and it still didn’t after I focused and left it.</p><p><strong>`reportValidity()` and `checkValidity()` don’t trigger it.</strong> Calling either on the form flagged nothing. A click on the submit button, Enter in a field and `form.requestSubmit()` all did.</p><p><strong>`novalidate` forms are flagged too.</strong> With `novalidate` on the form, the submit went through and the fields still matched `:user-invalid`. That’s useful if you show your own messages, and a surprise if you expected `novalidate` to turn everything off.</p><p><strong>It isn’t announced.</strong> In Chrome’s accessibility tree, a field that matched `:user-invalid` still had its `invalid` property set to false. A red border is a visual signal only. Link the message with `aria-describedby` as in use case 2, and set `aria-invalid` from script if you need it. I didn’t test a screen reader.</p><p><strong>CSS can’t tell which rule failed.</strong> A field is invalid or it isn’t, so you get one message per field unless script picks the text.</p><p><strong>I didn’t test everything.</strong> I didn’t try browser autofill or radio groups.</p><h4>How to think about this right now</h4><p>For new forms, style validation with `:user-invalid` and `:user-valid`, and delete the `touched` bookkeeping. If you use a form library for its other features, check whether its touched state is still doing anything the browser doesn’t.</p><p>For error messages, reveal them with `:has(:user-invalid)`, and keep them connected to the field for assistive technology.</p><p>If your current validation works and is tested, leave it. The next time someone reports a field that’s red before they typed, or a form that stays red after Reset, that’s the moment to switch.</p><p>The browser always knew whether the user had touched the field. CSS can ask it now.</p><p><strong><em>This is part of my series on practical web development in 2026. Next: CSS `scroll-state()` container queries, and styling a sticky header without a scroll listener.</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9da1fd327523" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codex/css-can-show-form-errors-only-after-the-user-types-most-developers-still-track-touched-state-9da1fd327523">CSS Can Show Form Errors Only After the User Types. Most Developers Still Track Touched State.</a> was originally published in <a href="https://medium.com/codex">CodeX</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Implement Authentication and Security in MCP: Protect Your AI Agents and Tools]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/codex/implement-authentication-and-security-in-mcp-protect-your-ai-agents-and-tools-7428c4f5923d?source=rss----29038077e4c6---4"><img src="https://cdn-images-1.medium.com/max/1672/1*9vykvhV751x1DEp7eCPxKA.png" width="1672"></a></p><p class="medium-feed-snippet">Part 8 of 10 &#x2014; Build AI Agents with MCP: From Basics to Real-World Applications</p><p class="medium-feed-link"><a href="https://medium.com/codex/implement-authentication-and-security-in-mcp-protect-your-ai-agents-and-tools-7428c4f5923d?source=rss----29038077e4c6---4">Continue reading on CodeX »</a></p></div>]]></description>
            <link>https://medium.com/codex/implement-authentication-and-security-in-mcp-protect-your-ai-agents-and-tools-7428c4f5923d?source=rss----29038077e4c6---4</link>
            <guid isPermaLink="false">https://medium.com/p/7428c4f5923d</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai-engineering]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[mcp-server]]></category>
            <dc:creator><![CDATA[Zayd Islam]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 13:18:17 GMT</pubDate>
            <atom:updated>2026-11-16T13:18:15.634Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[This MCP Can Find, Buy and Set Up a Domain. Without a Single Click]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/codex/your-ai-can-now-find-buy-and-set-up-a-domain-without-a-single-click-9a2652ee87f2?source=rss----29038077e4c6---4"><img src="https://cdn-images-1.medium.com/max/2020/1*oRwAUXjhtzWqOEOPldiZyQ.png" width="2020"></a></p><p class="medium-feed-link"><a href="https://medium.com/codex/your-ai-can-now-find-buy-and-set-up-a-domain-without-a-single-click-9a2652ee87f2?source=rss----29038077e4c6---4">Continue reading on CodeX »</a></p></div>]]></description>
            <link>https://medium.com/codex/your-ai-can-now-find-buy-and-set-up-a-domain-without-a-single-click-9a2652ee87f2?source=rss----29038077e4c6---4</link>
            <guid isPermaLink="false">https://medium.com/p/9a2652ee87f2</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[chatgpt]]></category>
            <category><![CDATA[claude]]></category>
            <dc:creator><![CDATA[AI Rabbit]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 13:18:12 GMT</pubDate>
            <atom:updated>2026-11-16T13:18:11.681Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Your Database Migration Worked. Your Deploy Still Broke Production.]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/codex/your-database-migration-worked-your-deploy-still-broke-production-9bbc205834f5?source=rss----29038077e4c6---4"><img src="https://cdn-images-1.medium.com/max/1280/1*1XkM94Ak7hWsCl9etlJjMA.jpeg" width="1280"></a></p><p class="medium-feed-snippet">A schema change can succeed in seconds and still break every app server that hasn&#x2019;t been replaced yet.</p><p class="medium-feed-link"><a href="https://medium.com/codex/your-database-migration-worked-your-deploy-still-broke-production-9bbc205834f5?source=rss----29038077e4c6---4">Continue reading on CodeX »</a></p></div>]]></description>
            <link>https://medium.com/codex/your-database-migration-worked-your-deploy-still-broke-production-9bbc205834f5?source=rss----29038077e4c6---4</link>
            <guid isPermaLink="false">https://medium.com/p/9bbc205834f5</guid>
            <category><![CDATA[database]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[postgresql]]></category>
            <dc:creator><![CDATA[Kisalay]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 13:18:07 GMT</pubDate>
            <atom:updated>2026-11-16T13:18:06.257Z</atom:updated>
        </item>
    </channel>
</rss>