Mert

NPM Supply Chain Compromise, cPanel Root RCE, AWS Pathfinding Labs

Today’s Highlights

A major npm supply chain attack compromised over 300 packages, while a critical cPanel CVE-2026-29205 allows pre-auth root file reads. Simultaneously, new AWS Pathfinding Labs offer hands-on training for cloud vulnerability exploitation and defense.

314 npm packages just got compromised, 271 @antv, echarts-for-react, size-sensor, timeago.js (r/cybersecurity)

Source: https://reddit.com/r/cybersecurity/comments/1thcbcf/314_npm_packages_just_got_compromised_271_antv/

This item details a significant and widespread supply chain attack that recently hit the npm ecosystem, impacting 314 distinct packages. The attack originated from the compromise of a maintainer’s account associated with the atool project, which was then used to push malicious versions across a vast array of popular packages. Affected libraries include @antv, echarts-for-react, size-sensor, and timeago.js, all widely used in web development projects. The malicious code injected into these packages is designed to exfiltrate sensitive developer credentials and environment variables, specifically targeting AWS keys, GitHub tokens, and other critical secrets from compromised build environments or individual developer machines. This incident underscores the profound and persistent risk posed by account compromises within package repositories, highlighting the urgent need for enhanced security measures.

Developers are strongly advised to meticulously review their project dependencies, particularly if they utilize any of the listed affected packages, to ensure no compromised versions are present in their dependency trees. This attack serves as a stark reminder of the critical importance of implementing robust supply chain security practices. These include mandatory multi-factor authentication for all package maintainers, rigorous automated scanning of dependencies for known malicious code or suspicious behavior, and strict access controls on development and deployment environments. Organizations should also consider adopting policies for regular credential rotation and adhering to the principle of least privilege, minimizing the scope of permissions granted to automated build systems and development tools. Proactive vigilance and layered defense are paramount in mitigating such sophisticated supply chain threats.

Comment: This is a classic supply chain attack scenario. Always verify package integrity and implement strong MFA on package manager accounts. Use tools to scan your node_modules for known malicious versions.

New Age of Collisions: Reading Arbitrary Files Pre-Auth as root in cPanel (CVE-2026-29205) (r/netsec)

Source: https://reddit.com/r/netsec/comments/1th9bpu/new_age_of_collisions_reading_arbitrary_files/

A critical vulnerability, CVE-2026-29205, has been disclosed in cPanel, allowing for pre-authenticated arbitrary file reading with root privileges. Dubbed “New Age of Collisions,” this flaw could enable attackers to read sensitive configuration files, authentication tokens, or even private keys from affected cPanel installations without needing any prior authentication. The impact is severe, as access to such files could lead to full system compromise, data exfiltration, or further lateral movement within a network. This vulnerability poses a significant risk to the vast number of web hosting providers and individual users who rely on cPanel for server management.

The technical write-up details how specific file collision techniques can be leveraged to exploit a weakness in cPanel’s handling of certain requests, bypassing authentication mechanisms and achieving high-privilege file access. Users running cPanel are strongly advised to apply patches immediately as they become available and to monitor their systems for any signs of compromise. Furthermore, hardening measures such as restricting network access to cPanel interfaces and implementing intrusion detection systems are crucial to mitigate the risks associated with such critical vulnerabilities.

Comment: A pre-auth root file read in cPanel is as bad as it sounds. Patch immediately, and audit your cPanel deployments for suspicious activity.

Pathfinding Labs: Deploy, test, and learn from 100+ intentionally vulnerable AWS environments (r/netsec)

Source: https://reddit.com/r/netsec/comments/1thjpl5/pathfinding_labs_deploy_test_and_learn_from_100/

Pathfinding Labs offers a unique and highly practical resource for cybersecurity professionals and developers seeking to deepen their understanding of AWS cloud security. This platform allows users to deploy, test, and learn from over 100 intentionally vulnerable AWS environments. Each lab is designed to simulate real-world misconfigurations and common vulnerabilities, covering areas like IAM privilege escalation, S3 bucket misconfigurations, vulnerable Lambda functions, and insecure network configurations. It’s an invaluable tool for hands-on practice, allowing users to safely experiment with attack techniques and understand their impact in a controlled environment.

The labs are structured to support a comprehensive learning experience, from identifying initial access vectors to achieving full compromise and exploring remediation strategies. This directly addresses the need for practical hardening guides and defensive techniques in cloud environments. By providing a sandbox for exploitation and defense, Pathfinding Labs empowers users to build practical skills in identifying, exploiting, and securing common AWS vulnerabilities, making it an essential resource for anyone involved in cloud security.

Comment: This is a fantastic resource for anyone wanting to get hands-on with AWS security. Spin up a lab, break it, fix it – the best way to learn practical cloud hardening.

AI Agents Observability, Python Logging for OTel, & PySpark Code Linter

Today’s Highlights

This week’s highlights focus on critical tooling and observability for AI systems in production. We cover essential tracing for AI agents, unifying Python logging with OpenTelemetry, and a PySpark linter for robust data pipelines.

Agent Traces Need to Cross the MCP Boundary (Dev.to Top)

Source: https://dev.to/focused_dot_io/agent-traces-need-to-cross-the-mcp-boundary-focused-labs-5f2l

This article delves into a critical observability challenge for AI agents operating within a “Multi-Component Pipeline” (MCP) architecture: the lack of comprehensive tracing across tool calls. As AI agents increasingly integrate external tools and services to achieve complex tasks, the execution flow often crosses the boundary between the agent’s core logic and these external tool invocations. The author highlights that while agent internal logic might be well-traced, the moment an agent makes a “tool call” through an MCP, the trace context often gets lost or becomes fragmented.

This gap in observability makes debugging, performance monitoring, and understanding agent behavior significantly harder. Without end-to-end traces that encompass the full lifecycle of a tool call – from initiation by the agent, through the MCP, to the tool’s execution and result return – developers struggle to pinpoint failures, identify bottlenecks, or even confirm successful operations. The piece emphasizes the need for a unified tracing mechanism that can propagate trace contexts seamlessly across these boundaries, enabling developers to gain complete visibility into their AI agent’s interactions with its environment and external services, which is crucial for robust production deployments.

Comment: This is a crucial read for anyone deploying AI agents; fragmented traces across tool calls are a silent killer for debugging and production stability. Implementing robust cross-boundary observability is non-negotiable for complex agent systems.

Bridging Python’s Logging Module to OpenTelemetry (Complete Guide) (r/Python)

Source: https://reddit.com/r/Python/comments/1thpfg9/bridging_pythons_logging_module_to_opentelemetry/

This guide provides a comprehensive walkthrough on integrating Python’s standard logging module with OpenTelemetry, a vendor-agnostic observability framework. The core challenge addressed is how to enrich existing Python log records with OpenTelemetry trace context without requiring extensive code changes to an application’s logging calls. This is particularly valuable for applications, including those using AI frameworks, that have established logging practices and need to transition to a more unified observability strategy.

The guide likely details how to configure a custom logging handler or filter that can automatically extract the current OpenTelemetry span and trace IDs and embed them into log records. This allows developers to correlate traditional log messages with distributed traces, providing a much richer context for debugging and performance analysis in complex microservice architectures or AI pipelines. By bridging these two systems, teams can leverage the detailed insights from OpenTelemetry traces while maintaining their familiar Python logging patterns, facilitating easier adoption of advanced observability practices in production environments.

Comment: A solid guide for unifying Python logging with OpenTelemetry. Essential for any production AI system to correlate logs with traces, especially in distributed agent or RAG setups.

I built a linter for PySpark Code (r/dataengineering)

Source: https://reddit.com/r/dataengineering/comments/1thic69/i_built_a_linter_for_pyspark_code/

This Reddit post announces a new VS Code extension designed to lint PySpark code, offering valuable assistance to data engineers and machine learning practitioners working with Apache Spark. The linter’s primary function is to identify unoptimized code, keep track of data types, and detect common Spark anti-patterns, which are crucial for ensuring efficient and robust data processing pipelines. Given that PySpark is a fundamental component in many large-scale data processing and machine learning workflows, a tool that helps maintain code quality and performance directly impacts the reliability and cost-effectiveness of these systems.

The extension provides real-time feedback within the VS Code environment, highlighting potential issues and suggesting improvements. This proactive approach helps developers write better-performing PySpark code from the outset, reducing the need for costly refactoring or debugging in later stages of development or production. Furthermore, the inclusion of Databricks support suggests its utility in cloud-based ML platforms, making it a practical tool for those deploying and managing AI-related data pipelines at scale.

Comment: As someone who wrangles PySpark for ML pipelines, an intelligent linter detecting anti-patterns and optimizing code is incredibly useful for maintaining robust and efficient systems. Pip install this to avoid common performance pitfalls.

PostgreSQL: New Time-Series Extension & Replication Monitor; DuckDB in Production

Today’s Highlights

This week’s highlights feature new PostgreSQL tools for time-series data and robust replication monitoring, alongside a practical discussion on deploying DuckDB in production environments. Developers can explore an Apache-licensed time-series extension and an HTTP discovery service for streaming replication with read-your-writes consistency.

pg_deltax (δx): Fast time-series extension for PostgreSQL (r/PostgreSQL)

Source: https://reddit.com/r/PostgreSQL/comments/1thvq2k/pg_deltax_δx_fast_timeseries_extension_for/

The pg_deltax project introduces an Apache-licensed time-series extension designed to enhance PostgreSQL’s capabilities for handling high-volume temporal data. Positioned as a fast, open-source alternative to specialized time-series databases or proprietary extensions like TimescaleDB, it aims to tackle common challenges associated with time-series workloads, such as efficient data ingestion, optimized storage, and rapid analytical querying.

Time-series data, prevalent in IoT, financial applications, and system monitoring, demands specialized indexing and compression techniques to ensure performance and reduce storage footprint. pg_deltax likely implements these optimizations at a lower level within PostgreSQL, potentially offering faster aggregations, time-window queries, and data retention policies crucial for these use cases. Its open-source nature with an Apache license promotes broader adoption and community contributions, offering a flexible and powerful tool for developers and data engineers building scalable data platforms around PostgreSQL.

Comment: This extension is a game-changer for anyone struggling with time-series performance on vanilla PostgreSQL. I’m keen to test its benchmarks against existing solutions and integrate it into my monitoring stack.

pg-status 2.1.0 — HTTP discovery for PostgreSQL streaming replication, now with read-your-writes (r/PostgreSQL)

Source: https://reddit.com/r/PostgreSQL/comments/1thok27/pgstatus_210_http_discovery_for_postgresql/

pg-status is a lightweight C microservice that provides an HTTP API for discovering and monitoring the status of PostgreSQL streaming replication. The newly released version 2.1.0 introduces a significant feature: read-your-writes consistency. This enhancement ensures that applications querying replica databases can guarantee they see data that has been committed to the primary, even in scenarios where replication lag exists.

This capability is critical for maintaining data integrity in distributed systems, where stale reads from lagging replicas can lead to inconsistent application states. pg-status achieves this by exposing detailed replication metrics, including lag, which can be leveraged by load balancers or application logic to route read queries only to replicas that meet specific freshness requirements. Its compact C implementation ensures minimal overhead, making it an efficient solution for improving the robustness and reliability of PostgreSQL-backed services that rely heavily on streaming replication for high availability and read scalability.

Comment: Achieving read-your-writes consistency across PostgreSQL replicas often requires complex application-level logic. This microservice streamlines that, making it much easier to build resilient, distributed systems.

DuckDB (r/dataengineering)

Source: https://reddit.com/r/dataengineering/comments/1thm69a/duckdb/

This discussion thread on r/dataengineering explores the practical experiences and considerations of implementing DuckDB in a production-grade environment. DuckDB, an in-process analytical SQL database, has gained significant traction for its performance and ease of use in local data analysis and embedded scenarios. The community conversation likely delves into its suitability for real-world, scalable deployments, addressing aspects like concurrency management, persistent storage strategies, integration with existing data pipelines, and potential trade-offs compared to traditional client-server OLAP databases.

A key point of discussion revolves around the current lack of a managed cloud service for DuckDB. This highlights a common operational challenge for organizations aiming to leverage DuckDB’s benefits without incurring the overhead of self-managed infrastructure for backups, scaling, and high availability. Insights from the thread are invaluable for data architects and engineers evaluating DuckDB, offering a nuanced view of its strengths as an embedded analytical engine for specific production use cases, such as local data transformation, edge computing analytics, or as a component in a broader hybrid data architecture.

Comment: Moving DuckDB from a local tool to production is a common dilemma. This discussion offers critical real-world insights into its operational challenges and the need for a managed service for broader enterprise adoption.

Intel Xe3P Leaks 160GB LPDDR5X; FlashAttention-2 in CuTe & Custom CUDA GPT-2 Engine

Today’s Highlights

Intel’s Xe3P “Crescent Island” GPU leaks reveal 160GB LPDDR5X VRAM, sidestepping HBM shortages and showcasing a powerful new silicon roadmap. Meanwhile, developers are diving deep into CUDA with a line-by-line FlashAttention-2 CuTe walkthrough and a GPT-2 inference engine built from scratch.

FlashAttention-2 in CuTe, From Scratch: A Line-by-Line Walkthrough (r/CUDA)

Source: https://reddit.com/r/CUDA/comments/1thw5o1/flashattention2_in_cute_from_scratch_a_linebyline/

This article provides an in-depth, line-by-line walkthrough of re-implementing FlashAttention-2 using NVIDIA’s CuTe library on Ampere architecture. The author, having spent months mastering CuTe, meticulously breaks down Tri Dao’s original source code to explain the complex memory management, tiling strategies, and kernel optimizations essential for high-performance attention mechanisms on modern GPUs. This resource is invaluable for CUDA developers aiming to understand and apply advanced VRAM optimization techniques directly relevant to large language models.

The walkthrough delves into how CuTe facilitates fine-grained control over GPU hardware, enabling developers to write highly optimized kernels that maximize memory bandwidth and reduce latency. It covers critical aspects such as shared memory usage, register blocking, and the intricate choreography required to handle data movement efficiently within the GPU’s memory hierarchy. By dissecting FlashAttention-2, a cornerstone technique for reducing VRAM consumption and increasing throughput in transformer models, the article empowers readers to build their own optimized CUDA kernels for machine learning workloads.

Comment: This walkthrough is a masterclass in modern CUDA programming, offering unparalleled insight into VRAM optimization with CuTe. Any developer looking to squeeze maximum performance from their NVIDIA GPUs for LLMs needs to read this and apply the techniques.

Intel Crescent Island PCB Leaks: Massive Xe3P GPU with 160GB LPDDR5X (r/LocalLLaMA)

Source: https://reddit.com/r/LocalLLaMA/comments/1thxig9/intels_crescent_island_pcb_leaks_showing_a/

Leaked PCB images for Intel’s upcoming “Crescent Island” data center GPU reveal a massive Xe3P architecture, signaling Intel’s aggressive entry into the high-performance computing market. A standout feature is the inclusion of 20 8GB LPDDR5X modules, providing an unprecedented 160GB of total VRAM. This strategic choice of LPDDR5X over High Bandwidth Memory (HBM) is likely a direct response to the ongoing HBM supply shortages, allowing Intel to maintain high memory capacity while potentially sidestepping production bottlenecks.

The leak also indicates a substantial 640-bit wide memory interface, suggesting a formidable memory bandwidth designed to feed the large Xe3P GPU. This move highlights Intel’s silicon roadmap for data center accelerators, focusing on high memory capacity and alternative memory solutions to meet the growing demands of AI and large language model workloads. The 16-pin connector further implies significant power delivery requirements, aligning with expectations for a high-performance, enterprise-grade GPU.

Comment: Intel’s pivot to LPDDR5X for 160GB VRAM on Xe3P is a fascinating workaround for HBM shortages, potentially disrupting the data center GPU memory landscape. This leak offers a crucial glimpse into their next-gen hardware strategy.

GPT-2 Inference Engine Built From Scratch in CUDA (r/CUDA)

Source: https://reddit.com/r/CUDA/comments/1tgnqif/built_a_gpt2_inference_engine_from_scratch_in_cuda/

A developer has announced the creation of a GPT-2 inference engine entirely from scratch using CUDA, demonstrating a deep understanding of GPU architecture and parallel programming for transformer models. This project is a robust example of how to implement the core components of an LLM efficiently on NVIDIA GPUs, offering a valuable learning resource for those looking to optimize AI workloads at a low level. It features key optimizations such as tiled GEMM (General Matrix Multiply) kernels and fused attention + softmax kernels, which are crucial for minimizing memory access and maximizing computational throughput.

The engine also incorporates multi-head causal self-attention and complete transformer blocks, along with MLPs (Multi-Layer Perceptrons) and a KV cache for autoregressive token generation. By building these components from first principles in CUDA, the project provides a highly optimized foundation for running transformer-based models, directly addressing performance and VRAM efficiency. This initiative serves as a practical blueprint for developers aiming to build or enhance their own custom inference solutions for generative AI.

Comment: Building a GPT-2 engine in raw CUDA is an impressive feat, showcasing practical GPU optimization for LLMs. This project is a goldmine for understanding how to write performant CUDA kernels for transformer components like GEMM, attention, and KV cache.

For a while I’ve been “experimenting” with AI-assisted development; which meant opening a chat window, describing what I wanted, and hoping for the best. This is about what I built to make it more reliable than that — and how every fix turned out to be something good engineering teams already do.

The project

I work in a field where software reliability genuinely matters — we have contracts with local government, SLAs, and the kind of accountability where “the AI did it” is not a defensible answer. So before bringing AI-first development into that context, I wanted to stress-test it somewhere lower-stakes but structurally similar.

In my spare time I’ve built and maintain Muddle — a meal planner I built for my own household. It’s a real Rails app, in daily use, and my household depends on it to actually plan meals. I can’t vibe-code changes into production — there are hungry people who would notice if the weekly plan disappeared. The constraints that mattered at work showed up here too: existing project, real users, code quality that another human could read and maintain. Just at a friendlier scale.

Stage one: just asking, and why that didn’t work

The obvious starting point is also the one everyone tries first: describe what you want, let the model run with it. And it’s fine for throwaway scripts or isolated functions. But for a living codebase with existing conventions and real users, it breaks down quickly.

The problems I kept running into were:

Plain old misunderstood requirements. I’d ask for a change and get something that technically works but not what I actually wanted. It was in the wrong place, or it worked in a way that didn’t make sense to me or the users.

Drift from conventions. The app has a particular way of doing things — Rails idioms, ViewComponent patterns, specific test structures. A generic prompt produced generic code that didn’t fit.

No checkpoint. The model would make three decisions I’d have made differently, and I’d only find out when I looked at the diff. By then I was either accepting the whole thing or untangling it manually.

None of these are catastrophic on their own. But they compound. After a few sessions of cleanup work following “successful” prompts, I realised I was spending more time correcting Claude than I would have spent just writing the code.

There’s an old mantra in software engineering: the computer does exactly what you tell it, not what you want. That’s still true with AI — it’s just harder to see. The gap between “what you said” and “what you meant” is buried in the interpretation of natural language rather than a compiler error. The AI fills in blanks well enough that a misunderstanding feels like a reasonable attempt rather than a crash. At least a compiler tells you immediately that you got it wrong.

Stage two: telling Claude how we do things here

Even when Claude understood what to do, the code it produced didn’t look like the rest of the codebase. Not broken — just wrong for this project. Instance variables where we use locals. Rubocop conventions instead of Standard Ruby. Minor things, but the kind that get flagged in a code review. Someone has to clean it up, and that someone is me.

The fix was CLAUDE.md — a file that Claude reads automatically as context for every session. Coding conventions, style rules, migration handling, test structure. It’s the same thing a good CONTRIBUTING.md does in an open source repo: here’s how we work, here’s what we care about, here’s what will get your PR rejected. The agent is just a new contributor who needs the same onboarding.

This worked. The code started looking like it belonged in the codebase.

Stage three: only load what’s relevant

The CLAUDE.md approach introduced a different problem almost immediately. When I was having a conversation about the logo, or thinking through a product decision, the coding rules were sitting in context the whole time. Suggestions had a slight pull toward code. Discussions about what something should look like would drift toward how it might be implemented.

The fix was treating CLAUDE.md as a map rather than a dump. The top-level file became a short index pointing to linked documents, and each conversation only loads what’s relevant to it. None of them load all of it.

The reason for the structure wasn’t agents — it was regular prompts drifting in the wrong direction because of rules that had nothing to do with the conversation at hand. Agents benefited from the same approach later, but that came after. It’s the same instinct as not handing a developer every company policy document before asking them to fix a bug — give people what’s relevant to the task, not everything that exists.

Stage four: better briefs, and the proto-epic

Instead of describing what I wanted, I started asking Claude to reflect the requirement back at me — what it understood, what it would change, what it wouldn’t. This caught misunderstandings before they became diffs. It also forced me to think more clearly about what I actually wanted.

This evolved into something more structured: drafting the requirement in a file, iterating until we both agreed on what success looked like. That’s just acceptance criteria — getting shared agreement on what “done” means before any work starts. I wasn’t inventing anything; I was rediscovering why that practice exists. Those files became the basis for the epic documents in the project. It just turned out that “a well-reasoned, scoped description of what to build and why” is exactly what an epic is.

Stage five: a Head of Product agent

The next gap was that I was still the one deciding what to build. I’m the founder (that’s what Claude keeps calling me — I never asked it to), which means I have the usual blind spots — attached to ideas, optimistic about scope, bad at killing the darlings.

I created a Head of Product agent with a specific brief: consistent product thinking, honest challenge, anchored to the user archetype. Not “build what I say” but “is this actually the right thing to build?” The HoP would push back on briefs that were solving the wrong problem, suggest smaller versions of ideas, or flat out tell me something wasn’t worth building yet.

A side effect of those conversations was that decisions needed somewhere to live. Which ideas were worth building, which were parked and why, what order things should happen in — that’s a roadmap, and it emerged from the conversations rather than being written upfront. Now it lives in the project as a document agents read when making prioritisation decisions, rather than reconstructing the logic from scratch every time.

Stage six: visual identity and brand documentation

Every time I worked on a brief that touched the UI or copy, the same questions came up. What’s the tone? What’s the font? Is this on brand? And I was answering them from scratch each time — or worse, answering them slightly differently each time.

The decisions had been made. I knew the typeface, the colour direction, the brand personality. None of it was written down, which meant every brief that touched design or copy was relitigating it.

So I wrote docs/visual-identity.md and docs/product-positioning.md — not to prevent drift in output, but to stop having the same conversations. Written down once, referenced forever. Briefs got shorter and sharper, and the decisions became easier to challenge and update rather than existing as a fuzzy shared understanding that no one could quite articulate.

Stage seven: feature documentation

Once I started being deliberate about what each prompt loaded, it became obvious that the HoP agent had a different problem: not enough context about the app to do its job without going looking for it.

Left to its own devices, it would explore the entire codebase on every task — burning tokens re-discovering things it had found last session. Or it would ask me questions I’d answered before. Or — most frustrating — write briefs full of conditionals: “if the app already has email infrastructure, do X, otherwise do Y.” That’s not a brief, that’s a brief with a question buried in it.

The fix was feature documentation — a clear enough picture of what the app does and how it’s put together that the HoP could answer those questions itself. Does the app send emails? Yes, here’s how. Is there already a notifications system? No. Written down once, the agent stops asking and the briefs become definitive rather than conditional.

This is the same problem that exists on real teams — a product owner who has to ask a developer how something works before writing a sensible brief, or doesn’t ask and hedges with conditionals instead. The agent just makes the cost of not having documentation more visible, because it’ll ask you the same question every single session.

Stage eight: a Head of Engineering agent

By this point the product thinking was solid and the documentation was good, but I still had the checkpoint problem. Agents would get a brief, understand it correctly, then immediately start making changes — including changes I’d have stopped if I’d been asked.

The Head of Engineering agent was the answer. Its job is to turn a brief into an implementation plan before any code is written. The plan gets reviewed. I can push back on the approach, flag something dangerous, or redirect before anything gets changed. Good teams do this as a matter of course: a tech spec or design review gets signed off before anyone writes a line. The HoE is just that process applied to an agent. It’s much easier to say “don’t touch the authentication layer” at the plan stage than to untangle a diff where it got touched anyway.

What this whole thing actually is

What I ended up building is a lightweight version of the organisational infrastructure that already exists in good engineering teams. The documentation is the same documentation you’d write for a new human engineer. The agents are the roles you’d see in a small product team. The review checkpoints are the checkpoints you’d expect in any professional codebase.

None of this was the plan. I started by trying to get Claude to make a small change to a meal planner. The setup emerged from noticing where things went wrong and adding structure to prevent it — a series of informal retrospectives. Something doesn’t work, you figure out why, you add the structure that would have prevented it. Same thing good teams do after every sprint, just without the sticky notes.

Gemini 3.5 Flash, Claude Design, & LLM Source Reliability Insights

Today’s Highlights

Google rolls out Gemini 3.5 Flash for faster, more cost-effective AI applications, while developers demonstrate innovative, budget-friendly multimodal content creation using Claude Design and Eleven Labs. Simultaneously, new reports highlight critical challenges in LLM transparency, as Claude perplexingly cites Iranian state media without explanation, urging heightened scrutiny for commercial AI outputs.

Google just dropped Gemini 3.5 Flash (r/artificial)

Source: https://reddit.com/r/artificial/comments/1thuxcj/google_just_dropped_gemini_35_flash/

Google has officially released Gemini 3.5 Flash, the latest addition to its commercial Gemini family of models, tailored for developers prioritizing speed and cost-efficiency. This ‘Flash’ variant is engineered to deliver a compelling balance between rapid inference, lower computational costs, and robust performance, making it an optimal choice for high-throughput, latency-sensitive AI applications. Such applications include real-time conversational agents, dynamic content summarization, efficient data extraction, and other scenarios where quick responses are paramount. Developers can integrate Gemini 3.5 Flash via Google’s AI API, benefiting from anticipated optimizations in processing speed and reduced per-token pricing compared to its more powerful, but resource-intensive, siblings like Gemini 3.5 Pro. This update signifies Google’s commitment to providing a versatile suite of AI models, enabling developers to build and scale their AI-powered features across a broader range of use cases while maintaining economic viability. The model is also expected to offer enhanced capabilities in handling multimodal inputs, further extending its utility in complex development environments.

Comment: This is big for real-time applications. If 3.5 Flash lives up to its name, it could drastically lower operational costs and latency for many production systems currently using older Gemini models, making advanced AI more accessible for high-volume tasks.

Checkout this Explainer Video, Made in under $1 with Claude Design + Eleven Labs (r/artificial)

Source: https://reddit.com/r/artificial/comments/1thf55q/checkout_this_explainer_video_made_in_under_1/

This story highlights an innovative and highly practical approach to generating explainer videos at minimal cost, leveraging the synergy between commercial AI services: Claude Design for visual animation and Eleven Labs for high-fidelity synthetic speech. The workflow described tackles a common challenge in AI-powered content creation: seamlessly integrating distinct AI outputs. By using Claude Design, developers can create compelling visual narratives or animations, which are then enhanced with natural-sounding voiceovers generated by Eleven Labs’ advanced text-to-speech API. The process demonstrates how to address issues like audio synchronization and narrative flow, making it possible to produce a complete, polished explainer video for less than a dollar. This showcases the immense potential of multimodal AI integrations, offering a blueprint for developers to rapidly prototype and scale video content production without requiring extensive resources or specialized multimedia skills. It underscores how accessible commercial AI APIs are empowering a new generation of content creators and developers to bring their ideas to life efficiently and affordably.

Comment: Love seeing concrete, affordable multimodal examples like this. It’s a great blueprint for developers to integrate commercial AI services for quick content generation, especially bridging visuals and audio, and it’s something anyone can try today.

Claude Is Citing Iranian State Media. It Doesn’t Know Why. (r/artificial)

Source: https://reddit.com/r/artificial/comments/1ti0dhl/claude_is_citing_iranian_state_media_it_doesnt/

A recent report has brought to light a significant operational challenge for Anthropic’s Claude, a leading commercial AI model: its tendency to cite Iranian state media sources in its responses without a clear, self-explainable rationale. This unprompted behavior raises critical questions for developers and enterprises that integrate commercial AI APIs into their products, particularly concerning data provenance, algorithmic transparency, and potential biases inherent in large language model training data. When an AI generates output referencing sources known for state propaganda, it introduces risks related to misinformation and trust. This incident underscores the imperative for developers to implement robust verification layers and source validation mechanisms within their AI-powered applications. It is a stark reminder that even sophisticated commercial LLMs can exhibit emergent, unexplainable behaviors due to their vast and often opaque training datasets, necessitating careful human oversight and post-processing to ensure the accuracy, neutrality, and reliability of AI-generated content, especially in sensitive or critical domains like news summarization or geopolitical analysis.

Comment: This is a crucial reminder for anyone building with large language models. Always validate sources and be aware that even advanced commercial models can exhibit opaque, problematic behaviors due to their training data, impacting reliability and trust.

Local LLMs: Bytedance Lance 3B Multimodal, llama.cpp MTP, Ollama Client

Today’s Highlights

This week, Bytedance unveiled Lance, a 3B parameter open-source multimodal model accessible for consumer GPUs, alongside significant Multi-Threaded Pipelining improvements in llama.cpp boosting local inference speeds. Additionally, the new Horizon Flutter chat client offers multi-platform access for Ollama and other local/cloud AI models, simplifying self-hosted deployment.

Bytedance Releases Open-Source Lance 3B Multimodal Model (r/LocalLLaMA)

Source: https://reddit.com/r/LocalLLaMA/comments/1thkwgk/bytedance_released_an_open_source_model_that/

Bytedance has introduced Lance, a new open-source, lightweight native unified multimodal model boasting only 3 billion parameters. This model is designed to perform a wide array of tasks involving both image and text, making it a versatile option for developers. The low parameter count is a significant advantage, allowing Lance to be potentially run on consumer-grade GPUs, democratizing access to powerful multimodal AI capabilities.

Lance’s focus on a “unified multimodal” architecture means it can process and generate content across different modalities seamlessly, aiming to overcome the limitations of models specialized in only one domain. The release provides a direct link to its Hugging Face repository (https://huggingface.co/bytedance-research/Lance), enabling developers to immediately experiment with the model, integrate it into their projects, or fine-tune it for specific applications. This aligns perfectly with the trend of making advanced AI models accessible for local inference and self-hosted deployments.

Comment: A 3B parameter multimodal model is exciting, as it could open up on-device AI applications for many without needing specialized hardware. The “unified” aspect suggests a truly integrated multimodal capability.

llama.cpp Receives Multi-Threaded Pipelining (MTP) Performance Boost (r/LocalLLaMA)

Source: https://reddit.com/r/LocalLLaMA/comments/1thlmsx/time_to_update_llamacpp_to_get_som_mtp/

A recent update for llama.cpp, the popular C/C++ inference engine for LLaMA and other large language models, introduces significant Multi-Threaded Pipelining (MTP) improvements. This enhancement is crucial for optimizing performance, especially on consumer hardware, by allowing different stages of the inference process to run concurrently across multiple threads. Such optimizations are key for achieving faster token generation rates and lower latency during local LLM inference.

The improvements, detailed in a GitHub pull request (https://github.com/ggml-org/llama.cpp/pull/23269), directly address the need for more efficient resource utilization. For users running llama.cpp on their local machines, this translates to a tangible speed-up in model responsiveness and overall user experience. Maintaining and accelerating core tools like llama.cpp is vital for advancing the local AI ecosystem, making larger and more complex models practical to run outside of cloud environments.

Comment: Any performance boost in llama.cpp is always welcome for local inference enthusiasts. MTP improvements are specifically good for leveraging multi-core CPUs and potentially reducing latency.

Horizon Flutter Client Integrates Ollama for Local & Cloud AI Chat (r/Ollama)

Source: https://reddit.com/r/ollama/comments/1thyy0o/horizon_multiprovider_flutter_chat_client_ollama/

Horizon is a new open-source, multi-provider Flutter chat client designed to work seamlessly with both local and cloud-based AI models, with strong support for Ollama. This cross-platform application extends AI chat capabilities to a wide range of devices, including Android, macOS, Windows, and Linux (.deb / tar.gz), providing a unified interface for interacting with various LLMs. Its multi-provider nature means users can switch between local Ollama models, Claude, OpenAI, and Gemini, offering flexibility in choosing their preferred inference source.

The client allows users to leverage the power of local inference via Ollama, making it an excellent tool for those focused on privacy, cost-efficiency, or simply running open-weight models on their self-hosted setups. By providing a ready-to-use GUI for local models, Horizon simplifies the deployment and interaction experience for everyday users, bypassing the need for complex command-line operations. This development enhances the self-hosted AI ecosystem by offering a practical and accessible way to manage and utilize diverse AI models locally.

Comment: A multi-platform client that integrates Ollama is highly practical for anyone looking for a user-friendly interface for their local LLMs. The ability to switch between local and cloud providers in one app is a big plus.

I’ve been building a personal analytics stack for my GitHub and DEV.to presence — traffic reports, bot audits, the works. While auditing my 97 GitHub followers today, I noticed something in the heuristic scores that didn’t add up. Eight accounts, created across different years, flagged for mass following. Nothing unusual on the surface.

Then I looked at the following counts.

canestein   → 29,835 following  (created 2015)
hazexone    → 29,857 following  (created 2017)
domcomit    → 29,833 following  (created 2018)
kylehyne    → 29,837 following  (created 2018)
jaderytm    → 29,832 following  (created 2018)
vierystein  → 29,833 following  (created 2019)
hanyvert    → 29,839 following  (created 2020)
mariwatts   → 29,832 following  (created 2021)

Eight accounts. Created across a six-year span. Following counts within a range of 25.

That’s a hard pattern to explain organically. GitHub’s API and UI both expose following behavior at scale, and accounts that hit a shared ceiling tend to stop there — whether by design or because the automation was never told to go further. Worth noting: it’s also possible these accounts independently approached a natural platform-level follow limit. What makes this interesting isn’t the ceiling alone — it’s what the following-list overlap reveals underneath it.

These are publicly visible GitHub accounts. I am publishing their names because the methodology is only verifiable if the data is reproducible.

The Naive Test Failed — By Design

First thing I did was check whether they followed each other. Classic botnet detection — if accounts are from the same operator, they often follow each other to build mutual social proof.

Cross-follow matrix:
              canestein  hazexone  domcomit  kylehyne  jaderytm  vierystein  hanyvert  mariwatts
canestein         -         no        no        no        no        no          no        no
hazexone         no          -        no        no        no        no          no        no
domcomit         no         no         -        no        no        no          no        no
kylehyne         no         no        no         -        no        no          no        no
jaderytm         no         no        no        no         -        no          no        no
vierystein       no         no        no        no        no         -          no        no
hanyvert         no         no        no        no        no        no           -        no
mariwatts        no         no        no        no        no        no          no         -

All zeros. Clean matrix. A naive detector would stop here and clear them.

They do not follow each other — which is exactly why a shallow detector would miss them. That’s the evasion. The absence of cross-following isn’t an innocent signal; it’s a design choice.

The Important Signal Wasn’t Cross-Following

The important signal was not that these accounts followed each other. They did not. The important signal was that they followed almost the exact same external population. Cross-follow analysis missed the cluster entirely. Following-list overlap exposed it.

I pulled the full following lists for all 8 accounts — ~29,800 entries each, roughly 238,000 following records total requiring ~2,400 paginated API requests — and computed pairwise Jaccard similarity scores.

account_a       account_b         shared    jaccard    a_overlap  b_overlap
jaderytm        mariwatts          29,829    0.9998     0.9999     0.9999
kylehyne        mariwatts          29,831    0.9998     0.9998     1.0000
kylehyne        jaderytm           29,831    0.9998     0.9998     1.0000
domcomit        hanyvert           29,831    0.9997     0.9999     0.9997
canestein       jaderytm           29,828    0.9996     0.9998     0.9999
canestein       mariwatts          29,827    0.9996     0.9997     0.9998
canestein       kylehyne           29,829    0.9995     0.9998     0.9997
jaderytm        vierystein         29,810    0.9985     0.9993     0.9992
vierystein      mariwatts          29,810    0.9985     0.9992     0.9993
kylehyne        vierystein         29,812    0.9985     0.9992     0.9993
canestein       hanyvert           29,813    0.9984     0.9993     0.9991
domcomit        jaderytm           29,808    0.9984     0.9992     0.9992
domcomit        mariwatts          29,807    0.9983     0.9991     0.9992
domcomit        kylehyne           29,809    0.9983     0.9992     0.9991
canestein       vierystein         29,808    0.9983     0.9991     0.9992
canestein       domcomit           29,807    0.9982     0.9991     0.9991
jaderytm        hanyvert           29,807    0.9981     0.9992     0.9989
hanyvert        mariwatts          29,807    0.9981     0.9989     0.9992
kylehyne        hanyvert           29,809    0.9981     0.9991     0.9990
domcomit        vierystein         29,789    0.9971     0.9985     0.9985
vierystein      hanyvert           29,788    0.9968     0.9985     0.9983
hazexone        domcomit           29,732    0.9925     0.9958     0.9966
hazexone        hanyvert           29,730    0.9921     0.9957     0.9963
hazexone        vierystein         29,708    0.9909     0.9950     0.9958
hazexone        jaderytm           29,707    0.9908     0.9950     0.9958
hazexone        mariwatts          29,706    0.9908     0.9949     0.9958
hazexone        kylehyne           29,708    0.9907     0.9950     0.9957
canestein       hazexone           29,706    0.9907     0.9957     0.9949

Jaccard similarity of 0.99+ means two sets are nearly identical. Every single pair in this cluster scored above 0.99.

The cluster-level result:

29,682 accounts followed by all 8 members simultaneously.

Eight accounts, created across six years, following an almost identical list of ~29,800 GitHub users. This pattern is consistent with a shared operator, shared automation pipeline, or shared seed-list source. I’m treating this as behavioral evidence of coordination, not as proof of who controls the accounts.

Reading the Evidence

Aged accounts — created 2015-2021, not fresh throwaways. Aged accounts pass basic trust signals because they appear to have history. Whether that aging was deliberate or these are compromised/repurposed accounts is an open question, but from a detection standpoint it’s the primary reason shallow heuristics miss them.

No cross-following — they do not follow each other. Whether intentional or an artifact of how the automation was written, the effect is the same: it defeats the most common network detection method.

Identical seed list — the ~29,682 common follows are the operator’s target list. I’m on it. So are ~29,681 other GitHub users. The practical use case for maintaining aged accounts following a curated list of ~30,000 developers: engagement laundering (inflating follower counts on accounts used for phishing or spam campaigns), social proof for repositories seeding malicious packages, or resale as “established” GitHub accounts. The concrete finding here is the shared seed list itself. The downstream use is inference.

The tell they missed — following-list overlap. When you avoid cross-following but still use the same seed list, the overlap becomes the fingerprint. The more accounts in a cluster, the stronger the signal — and the harder it is to retroactively randomize without defeating the product.

Alternative Explanations and False Positives

Before calling something coordinated, it is worth asking what else could produce this pattern.

Could these accounts independently follow the same popular list? Possible for one or two pairs at moderate overlap. Not plausible at 0.9998 Jaccard across 29,800 accounts over eight accounts created years apart.

Could a shared import tool or browser extension have seeded them? Theoretically. That would still mean a shared automation pipeline — coordination by another name.

Could one of these be a legitimate account that happened to import a large follow list? Possible individually. The cluster-level result — all eight sharing 29,682 common accounts — rules this out as a coincidence across the group.

I am not proving malicious intent or ownership. I am documenting a statistically anomalous pattern that is consistent with coordinated inauthentic behavior and inconsistent with organic independent activity.

The Detection Method

Naive botnet detection looks for who accounts follow each other. Sophisticated operators defeat this. But they can’t easily defeat what they follow — because the seed list is the product. Changing it defeats the purpose.

The method:

1. Identify candidate cluster by shared behavioral signatures — following count ceiling, account age spread
2. Fetch full following lists for all candidates
3. Compute pairwise Jaccard similarity
4. Cluster-level intersection to find the common seed

Signal interpretation:

This generalizes to any platform that exposes following lists via API.

The Code

Rate limit note before you run this: fetching ~29,800 following entries per account costs ~300 API calls. GitHub’s authenticated limit is 5,000/hour. Eight accounts at this scale will approach that ceiling — spread runs across rate limit windows if your cluster is larger. GitHub also enforces secondary rate limits on rapid sequential requests independent of the hourly cap. If you hit a 403 or 429, respect the Retry-After header before retrying. Increasing time.sleep() from 0.1 to 0.5 between pages is safer for large clusters.

The full audit script is in BANANA_TREE. Core logic:

import urllib.request, json, os, time
from itertools import combinations

token = os.environ.get("GH_TOKEN")
headers = {
    "Authorization": f"token {token}",
    "Accept": "application/vnd.github.v3+json",
    "User-Agent": "gh-botnet-audit"
}

def get_following(login):
    following = set()
    page = 1
    while True:
        url = f"https://api.github.com/users/{login}/following?per_page=100&page={page}"
        req = urllib.request.Request(url, headers=headers)
        with urllib.request.urlopen(req, timeout=20) as r:
            data = json.loads(r.read())
        if not data:
            break
        following.update(u['login'] for u in data)
        if len(data) < 100:
            break
        page += 1
        time.sleep(0.1)
    return following

def jaccard(a, b):
    intersection = len(a & b)
    union = len(a | b)
    return intersection / union if union else 0

following_sets = {}
for login in cluster:
    following_sets[login] = get_following(login)

for a, b in combinations(cluster, 2):
    shared = len(following_sets[a] & following_sets[b])
    j = jaccard(following_sets[a], following_sets[b])
    print(f"{a:<20} {b:<20} shared={shared} jaccard={j:.4f}")

common = set.intersection(*following_sets.values())
print(f"Followed by ALL accounts: {len(common)}")

Run it as: python3 gh_botnet_audit.py GnomeMan4201

Reporting

I’ve reported this cluster to GitHub via their abuse reporting system with the account names, Jaccard scores, and the 29,682 common following count as supporting evidence.

To find candidate clusters in your own followers:

• Multiple accounts with suspiciously similar following counts
• Following count > 500 with no corresponding follower ratio
• Account ages spread across years (evasion signal, not conclusive alone)

The overlap analysis is what turns the heuristic into a defensible finding. The heuristics tell you where to look. The Jaccard matrix is what you bring to a report.

Tools

All tooling used in this research is in BANANA_TREE:

• gh_botnet_audit.py — GitHub follower scoring + overlap analysis
• traffic_report.py — GitHub + DEV.to analytics in one terminal run
• Python stdlib only — no external dependencies

This started as a weird follower-audit result. The real lesson is broader: when coordinated accounts avoid obvious links to each other, the shared target population becomes the fingerprint. Cross-following tells you who is connected. Following-list overlap tells you who was seeded from the same map.

The accounts named are publicly visible GitHub profiles. If you’ve run similar analysis on your own followers and found overlapping accounts from this same seed list, drop a comment — I’m curious how wide the network actually is.