Better orchestration, fewer handoffs, faster progress, without a single new knob. The post How we made GitHub Copilot CLI more selective about delegation appeared first on The GitHub Blog .

As of today, SpaceX is owned by investors who will want to see it make money.

Drop it. It's live. Discussion | Link

After covering the foundational building blocks in Session 1, the next step is one of the most important problem-solving techniques in all of programming: recursion . And once recursion feels comfortable, it unlocks a powerful search strategy called backtracking . These two concepts appear everywhere in competitive programming — Fibonacci, binary search, tree traversal, merge sort, dynamic programming, N-Queens, and more. They deserve their own spotlight. 🌟 What Is Recursion? A function is recursive if it calls itself. Instead of solving a problem in one go, a recursive function breaks it into a smaller version of the same problem, solves that, and repeats — until the problem becomes simple enough to answer directly. Three things define every recursive solution: The problem is expressed in terms of a smaller instance of itself Each call reduces the problem size There is a point where the problem becomes trivial and no further calls are needed — this is the base case The Nested Box Analogy Think of recursion like opening nested boxes. A big box contains a smaller box, which contains another, and so on. Eventually you find the item you were looking for. That innermost box is the base case. Without it, you would keep opening boxes forever — which is how you get a stack overflow, not a solution. Base Case and Recursive Case Every recursive function has exactly two parts: Recursive case — the problem is reduced in size and the function calls itself again. Base case — the terminating condition. No further recursive call is made. The function returns a direct answer. Both are non-negotiable. A function without a base case will keep calling itself, consuming stack memory until the program crashes. Example: Factorial 5! = 5 × 4! 4! = 4 × 3! 3! = 3 × 2! 2! = 2 × 1! 1! = 1 ← base case Each step reduces the problem by one. When the function hits 1! = 1 , it stops, and the results unwind back up the call stack. In pseudocode: function factorial(n): if n == 1: return 1 # base cas

AI Agent Security, Malware Evasion, & LLM Data Leakage Risks Today's Highlights Today's highlights cover crucial security challenges, from sophisticated malware evasion tactics confusing analysis tools to the inherent risks of autonomous AI agents causing financial damage. We also delve into the critical data security implications of interacting with large language models, emphasizing the need for robust data governance and user education. Malware developers added nuclear and biological weapons text to to their spyware (Hacker News) Source: https://twitter.com/jsrailton/status/2064661778978533571 This report highlights a concerning tactic employed by malware developers to evade detection and analysis. By embedding seemingly innocuous, yet contextually irrelevant, strings such as "nuclear and biological weapons" text within their spyware's code or data, threat actors aim to mislead security researchers and automated analysis tools. This technique, often referred to as 'camouflage' or 'noise injection,' complicates the process of signature-based detection and behavioral analysis by adding irrelevant data that can confuse pattern matching algorithms or human analysts investigating suspicious binaries. It leverages the expectation that malicious code should contain only code related to its function, subverting this by introducing data that might trigger false positives or simply overwhelm analysis efforts. This tactic necessitates more sophisticated defensive techniques, moving beyond simple string searches or basic heuristic analysis. Organizations must enhance their sandboxing capabilities, employ advanced machine learning-driven anomaly detection, and focus on dynamic analysis that observes the actual behavior of the malware rather than relying solely on static analysis. Understanding such obfuscation and evasion tactics is crucial for developing robust threat intelligence and improving the resilience of endpoint detection and response (EDR) systems against evolving

Local AI Coding Agents, Secure Production Deployment, and Angular-Specific AI Skills Today's Highlights This week's top stories highlight practical ways to deploy and secure AI agents, from setting up local coding assistants on macOS to sandboxing untrusted agent code in Azure, alongside new resources to improve AI-generated code quality for Angular. How to setup a local coding agent on macOS (Hacker News) Source: https://ikyle.me/blog/2026/how-to-setup-a-local-coding-agent-on-macos This guide provides a step-by-step tutorial on deploying and configuring an AI coding agent directly on a macOS system. The process typically involves setting up a local Large Language Model (LLM) or connecting to a local inference engine, integrating it with an orchestration framework, and configuring it to interact with local development tools and environments. The emphasis is on enabling developers to have a private, customizable AI assistant for code generation, debugging, and project scaffolding without relying on external cloud services. This local setup is crucial for privacy-conscious developers and for those who want to fine-tune agent behavior for specific internal codebases. The article likely covers prerequisites such as Python environments, relevant libraries, API key management for local models (if applicable), and how to set up the agent to execute code within a sandboxed environment on the machine. It offers a practical pathway for developers to experiment with AI agents in their daily coding workflows, providing immediate utility and control over the AI's operations and data handling. Comment: This is a great hands-on guide for anyone wanting to run AI coding agents locally, which is essential for privacy and custom development workflows. Run Untrusted AI Agent Code Safely with Azure Container Apps Sandboxes (InfoQ) Source: https://www.infoq.com/news/2026/06/untrusted-ai-agents-sandboxes/ Microsoft has announced the public preview of Azure Container Apps Sandboxes, a new

DuckDB Data Inlining, SQLite Fossildelta OOB, Postgres 19 Temporal Data Today's Highlights Today's highlights include DuckDB's innovative data inlining for stream processing in data lakes, offering significant performance gains by eliminating the small files problem. Additionally, a critical out-of-bounds read vulnerability in SQLite's fossildelta extension and a peek into PostgreSQL 19's focus on temporal data capabilities are discussed. Data Inlining in DuckLake: Unlocking Streaming for Data Lakes (DuckDB Blog) Source: https://duckdb.org/2026/04/02/data-inlining-in-ducklake.html The DuckDB team has unveiled DuckLake’s new data inlining feature, designed to revolutionize how streaming data is managed in data lakes by effectively tackling the notorious “small files problem.” This issue, common in scenarios with frequent small updates or continuous ingestion, often leads to performance bottlenecks due to the overhead of managing numerous tiny files. DuckLake's solution involves intelligently storing these small updates directly within the catalog, thereby eliminating the need for physical small files on disk. This architectural innovation significantly improves the practicality of continuous streaming into data lakes, enabling more efficient real-time analytics. By inlining data, DuckDB reduces I/O operations and metadata management complexity, leading to substantial performance gains. A benchmark highlighted in the announcement demonstrates an impressive 926x speed improvement for certain operations, showcasing the feature's potential to transform data lake architectures for workloads requiring high-throughput ingestion and immediate query access without the traditional performance penalties. Comment: This DuckDB feature is a game-changer for data lake architectures, offering a simple yet powerful way to handle streaming data without the performance overhead of countless small files. Post: Out-of-bounds read in deltaGetInt() when input contains no in-buffer terminat

AI Fluency for Software Engineers: A Practical Playbook Beyond Prompting A few years ago, being productive with AI mostly meant knowing which tool to open and what question to ask. Today, that is not enough. For software engineers, AI is no longer just a chatbot sitting outside the workflow. It is becoming a thinking partner for architecture decisions, code reviews, production incidents, documentation, test planning, onboarding, and product discovery. But there is a problem: many teams are using powerful AI tools with weak operating habits. They ask vague questions. They paste too much context. They trust the first answer. They forget privacy boundaries. They use AI for speed, but not always for better engineering judgment. That is where AI fluency matters. AI fluency is not just prompt engineering. It is the ability to work with AI clearly, safely, and practically while staying in control of quality, reasoning, and responsibility. Here is a practical playbook I would recommend for software engineers and engineering teams. 1. Start with clarity, not clever prompts A weak prompt sounds like this: “Review this design and tell me if it is good.” The AI can answer, but the answer will likely be generic. A stronger prompt gives the AI a clear role, context, constraints, and output format: You are a senior backend architect. Review this proposed API design for a high-traffic order processing system. Evaluate: - correctness - scalability - failure handling - observability - backward compatibility - operational complexity Do not rewrite the whole design unless required. Separate critical risks from optional improvements. Output format: - Executive summary - Key risks - Recommended changes - Open questions - Final decision recommendation The difference is not word count. The difference is control. A fluent AI user does not hope the AI understands the task. They make the task hard to misunderstand. 2. Give enough context, but not everything AI output quality depends heavily o

LLM KV Cache Optimization, Open Model Evaluation, & Agent Engineering Skills for Local Deployment Today's Highlights This week, a groundbreaking KV cache layer promises to supercharge local LLM inference, alongside a new workbench for evaluating open language models. Additionally, a trending repository provides production-grade engineering skills for building robust AI agents, crucial for self-hosted deployments. LMCache: Supercharge Your LLM with the Fastest KV Cache Layer (GitHub Trending) Source: https://github.com/LMCache/LMCache LMCache introduces a novel KV cache optimization layer designed to significantly accelerate Large Language Model (LLM) inference. The KV cache (Key-Value cache) is a critical component in LLM decoding, storing previously computed keys and values for attention layers to avoid redundant calculations. Optimizing this cache is paramount for achieving high throughput and low latency, especially when running large models on consumer-grade hardware or self-hosted servers. This project aims to provide the fastest KV cache solution, directly addressing a key bottleneck in local LLM deployment and performance. By improving KV cache efficiency, LMCache enables developers and researchers to run more complex models or serve more users with existing hardware, making advanced LLMs more accessible for local inference scenarios. Details on its architecture and comparative benchmarks against existing solutions will be critical for understanding its impact on various open-weight models and frameworks like vLLM or llama.cpp. Comment: Faster KV cache is a game-changer for anyone running LLMs locally. This project could unlock new performance levels for open models on consumer GPUs. olmo-eval: An evaluation workbench for the model development loop (Hugging Face Blog) Source: https://huggingface.co/blog/allenai/olmo-eval The olmo-eval workbench from AllenAI provides a comprehensive system for evaluating language models throughout their development lifecycle.

Interactive videos that talk back Discussion | Link

Competitive programming often looks like a race to write code as fast as possible. But the real secret is simpler: the best competitive programmers are not just faster typists — they are better at choosing the right data structure, the right algorithm, and the right complexity level for the job. Before we jump into recursion, dynamic programming, graphs, or those problems that make your brain do backflips, we need a solid base. This first session is exactly that. Let's begin. 🚀 1. Data Types: What Kind of Data Are You Storing? A data type tells a programming language what kind of value a variable holds and what operations are valid on it. Primitive Data Types The basic building blocks provided by the language itself: Integer — whole numbers: 5 , 100 , -3 Float / Double — decimal values: 3.14 , 99.5 Character — a single symbol: 'A' , 'z' Boolean — true or false User-Defined Data Types When primitive types are not enough, programmers define their own: Structs — group related fields under one name Classes — structs with behaviour (methods) attached Enums — a fixed set of named constants Typedefs / Aliases — rename existing types for clarity A Real-World Example Imagine building a food delivery app: An integer stores the number of items in the cart A float stores the total bill amount A boolean tracks whether the order has been delivered A class represents an entire Order — customer name, address, items, payment status Data types are essentially the labels on your containers. Without them, chaos begins early. 2. Data Structures: How Do You Organise Data? If data types answer what a value is, data structures answer how to organise many values efficiently. This is where competitive programming starts to get interesting. Linear Data Structures Elements arranged one after another, like people queuing at a ticket counter: Arrays — fixed-size, indexed, fast random access Linked Lists — dynamic size, efficient insertions and deletions Stacks — last in, first out (LIFO) Queues

Verdict: Quick verdict: Zapier wins on simplicity and breadth — 7,000+ integrations, no-code setup, great for non-technical users. Make (formerly Integromat) wins on power-per-dollar — complex multi-step workflows at a fraction of Zapier's price, with a visual canvas that's genuinely better for complex logic. n8n wins if you're technical and willing to self-host — unlimited workflows, unlimited runs, zero ongoing cost after setup. For most small businesses: Make. For enterprises with non-technical teams: Zapier. For technical founders or developers: n8n. The automation tool market matured a lot between 2022 and 2026. Zapier, once the clear leader, is now meaningfully more expensive than its competitors — and Make and n8n have closed most of the feature gaps. If you're still paying Zapier prices without re-evaluating, you're almost certainly paying 3-5x what you need to. This comparison covers all three tools honestly, including their limits — because the right choice depends heavily on your technical comfort level and workflow complexity. The three tools at a glance Factor Zapier Make n8n (cloud) Free tier 100 tasks/month, 5 Zaps 1,000 ops/month, unlimited scenarios 2,500 steps/month, unlimited workflows Paid starts at $19.99/month (750 tasks) $9/month (10,000 ops) $20/month (10,000 steps) Native integrations 7,000+ 1,500+ 400+ (plus HTTP for anything) Visual workflow editor Linear, simple Canvas, branching Node-based, very flexible AI integration Yes (AI actions) Yes (AI modules) Yes (LangChain, OpenAI, etc.) Self-hosted option No No Yes (free, unlimited) Learning curve Low Medium High (developer-focused) Zapier — the everything-just-works option Zapier's advantage is breadth and simplicity. 7,000+ apps (essentially anything with an API), a straightforward "trigger → action" model, and enough guardrails that non-technical users rarely get stuck. If you need to connect Salesforce to Slack to Google Sheets without touching any code, Zapier is the fastest path from id

Executives and employees alike are struggling with Meta's chaotic AI strategy, according to sources and internal discussions reviewed by WIRED.

The first message ever sent across the network that became the internet was not "Hello, world." It was not a grand declaration. It was two letters, transmitted by accident, before the system fell over: LO . That two-letter packet is the ancestor of every connected device, every IoT sensor, and every web request running today. The story of how it happened is also a surprisingly useful lesson for anyone building embedded systems and connected hardware right now. What actually happened on October 29, 1969 On the evening of October 29, 1969, a programmer named Charley Kline sat at a terminal in Leonard Kleinrock's lab at UCLA. His job was simple on paper: log in to a remote computer at the Stanford Research Institute (SRI), roughly 350 miles away, over a brand-new experimental network called ARPANET. The plan was to type the command LOGIN . The remote machine at SRI was set up to auto-complete the rest once it saw the first few characters, so Kline only needed to start typing. He had a colleague on the phone at the Stanford end to confirm each letter arrived. He typed L . Stanford confirmed: "Got the L." He typed O . Stanford confirmed: "Got the O." He typed G - and the SRI system crashed. So the first message ever transmitted over ARPANET was "LO." As Kleinrock later liked to point out, it was an accidental but fitting first word: "LO" as in "lo and behold." About an hour later they fixed the bug and completed the full login, but the historic first packet had already gone out, two letters at a time. Why a crash is the perfect origin story It is tempting to read this as a cute footnote. It is more than that. The very first thing the internet ever did was fail partway through a transaction - and the system was built well enough that the humans on both ends knew exactly how far it had gotten before it died. That is the entire discipline of networked systems in miniature. Connections drop. Remote machines crash mid-request. Packets arrive out of order, or not at all. The n