AI 资讯

A three-person agency received a $14,000 AWS bill in one day after attackers extracted static access keys and burned Claude invocations on Bedrock. Combined with May's DN42 incident, where an autonomous agent provisioned $6,531 of oversized infrastructure in 24 hours, practitioners warn that cloud billing lags roughly a day behind agent-speed spend. By Steef-Jan Wiggers

Protect your home against dust, pets, allergens, and more with the best air purifiers, tested firsthand.

Control work with your voice. The Siri for work. Discussion | Link

Colocar los muebles de una habitación es un problema de optimización con muchas restricciones: la cama no va delante de la puerta, el escritorio quiere luz natural, hay que poder circular. Hay un número enorme de disposiciones posibles. RoomCraft AI las explora automáticamente a partir de una descripción en lenguaje natural. El pipeline de tres etapas Parser con LLM: el usuario describe su habitación en texto libre ("un dormitorio de 4x3 con la puerta al norte y una ventana al este"). Un LLM ( Llama 3.1 vía Groq ) lo convierte en una estructura de datos validada con Pydantic : dimensiones, aberturas, muebles deseados. Latencia: <1s. Optimizador con Simulated Annealing: aquí está el corazón del proyecto. Visualización y export: los layouts se renderizan en 3D en el navegador con Three.js y se exportan como plano técnico en PDF con ReportLab . Por qué Simulated Annealing El espacio de disposiciones posibles es combinatorio y lleno de óptimos locales. Una búsqueda voraz se queda atascada en la primera solución "decente". El Simulated Annealing imita el enfriamiento de un metal: al principio acepta movimientos malos con cierta probabilidad (alta "temperatura"), lo que le permite escapar de óptimos locales; según baja la temperatura, se vuelve cada vez más exigente y converge. Es una metaheurística ideal cuando el espacio de soluciones es irregular y no tienes gradiente. La función objetivo puntúa cada disposición de 0 a 100 según ergonomía: espacio de circulación, relaciones entre muebles, acceso a luz y aberturas. El sistema devuelve el top 5 de layouts, no solo el mejor, para dar opciones. Rendimiento Parse: <1s . Optimización: 2–5s . Export PDF: <1s . Footprint en reposo: ~100 MB de RAM. Qué aprendí Que combinar un LLM (para entender lenguaje) con una metaheurística clásica (para optimizar de verdad) es un patrón potentísimo: el LLM traduce el problema humano a uno formal, y un algoritmo determinista y barato lo resuelve mejor —y de forma más explicable— que pedirle

Key Concepts 🗝️ These 11 tools have saved me thousands of hours over the past 4 years. If you're serious about becoming a better full-stack developer, they're worth mastering before chasing the next framework. Every year, dozens of new developer tools appear on Product Hunt, GitHub, and Hacker News. Some disappear within months. Others quietly become part of every professional developer's workflow. After years of building JavaScript applications, AI agents, browser automation projects, and technical content, these are the open-source tools I keep installing on every new machine. They solve different problems, but together they create a faster, cleaner, and more productive development environment. 1. Git Every developer eventually breaks something. The question isn't if . It's when . Git is the reason those mistakes rarely become catastrophes. Instead of thinking about Git as "version control," think about it as an unlimited undo button for your entire project. With Git you can: experiment without losing work create separate feature branches collaborate with teammates inspect old versions recover deleted work understand who changed what Without Git? Start over. With Git? git checkout main Problem solved. 2. Visual Studio Code Even with AI editors like Cursor becoming popular, VS Code remains the foundation of most modern development environments. VS Code is probably the application I spend more time inside than my browser. Yes it's "just" a code editor. But the extension ecosystem turns it into an entire development platform. My favorite extensions include: ESLint Prettier GitLens Error Lens Docker Thunder Client Playwright GitHub Copilot Together they create an environment where formatting, linting, debugging, testing, and Git management happen without leaving the editor. 3. Wave Terminal Wave Terminal is one of the most exciting open-source terminals I've used recently. Unlike traditional terminals, it transforms your command line into an interactive workspace wher

It feels as if it should be illegal to even think about heating appliances during the height of summer—seriously, these heat waves in New York have been brutal—but we need to talk about heat pumps. The appliances use electricity for heating, they’re incredibly efficient, and they’re on the rise. (For what it’s worth, many heat…

I’m sick of “opt-out” toggles for automatically enabled generative AI features. It’s past time to make “opt in” the default setting for sensitive features.

The group is trying to extend its influence beyond Meta.

What I learned at Zone01 Kisumu's IP training Introduction Yesterday, I attended an Intellectual Property training at Zone01 Kisumu, and it fundamentally changed how I think about the code I write. As developers, we spend countless hours building software, but how many of us truly understand the value of what we create,and how to protect it? In Kenya's rapidly growing tech ecosystem, understanding IP isn't just a legal nicety, it's a competitive advantage. Whether you're building an app, contributing to open source, or launching a startup, knowing your rights can mean the difference between owning your work and losing it. This article breaks down the essential IP frameworks every software developer should know. What is Intellectual Property in Software? Intellectual Property (IP) in software encompasses legal protections designed to safeguard the rights of creators and developers. The four primary types of IP protection relevant to software are: patents, copyrights, trademarks, and trade secrets . Copyright: Protecting Your Code Copyright is the most immediate form of protection for software developers. In Kenya, copyright protection arises automatically at the moment of creation,registration is not mandatory . This means that when you write code, you automatically own the copyright to that expression, provided the work is fixed in a tangible medium . However, a crucial distinction exists: copyright protects the expression of ideas, not the ideas themselves . This principle was reinforced in the Kenyan case of Solut Technology Limited v Safaricom Limited, where the court confirmed that without access to source code, it's difficult to prove infringement because the "expression" (the code itself) wasn't shared . Key Insight: Registering your copyright with KECOBO in Kenya provides prima facie evidence of ownership and can make enforcement faster if someone copies your work . Patents: Protecting Functionality While copyright protects the expression of code, patents pro

MCP for AWS Security Engineers: Build a Read-Only Security Hub Triage Agent For AWS-heavy security work, I would start with AWS Agent Toolkit for AWS and the managed AWS MCP Server , not a custom MCP server. The reason is practical. AWS now provides a managed MCP path that can connect AI coding agents to AWS documentation, AWS APIs, AWS skills, and existing IAM credentials. The Agent Toolkit also provides plugin-based setup for supported agents such as Claude Code and Codex. For security teams, that is the right starting point because the enforcement point remains AWS IAM, not the model. The initial operating model should be strict: Read-only first. No production write authority. No access to secrets. No raw customer PII or sensitive incident logs in prompt context. No automatic remediation. No AI-approved suppression, exception, merge, deploy, or risk acceptance. Human review and CI/CD remain the release authority. That is the same posture I would use for a governed Claude Code or Codex rollout: named identities, SSO, scoped credentials, default deny, tool approval, audit logs, and security evidence tied back to tickets, pull requests, CI logs, and cloud findings. What we are building This article walks through a practical security workflow: A read-only Security Hub triage assistant that helps a junior security engineer produce a daily or weekly findings summary, remediation backlog, and evidence pack without allowing the agent to modify AWS. The agent will be able to: Read AWS Security Hub findings. Group findings by account, severity, product, resource, and control. Explain why a finding matters. Draft remediation tickets. Draft a Slack-ready summary. Produce local markdown, CSV, and JSON evidence files. The agent will not be able to: Suppress findings. Archive findings. Mark findings resolved. Disable Security Hub standards. Modify IAM, S3, EC2, KMS, GuardDuty, Inspector, or Config. Deploy remediation. Run destructive scripts. Approve risk acceptance. This is no

A bug showed up in my personal project last month. Nothing dramatic - a value wasn't updating the way...

Building an AI agent with n8n is the fastest, cheapest way to turn a large language model into a useful worker — if you stay within its sweet spot. The honest truth, informed by the custom agents we ship, is that n8n carries a well-scoped agent further than most people expect. An LLM node, a few tool/webhook nodes and a trigger are all you need. This guide walks you through that exact workflow and, just as importantly, names the precise moment n8n stops cutting it and a custom build must take over. What You Need Before You Start You'll need a running n8n instance (self-hosted or cloud) and API keys for the services you want to integrate. Grab a Gemini or OpenAI key from their respective developer consoles — n8n's official AI agent builder documentation lists the full compatibility. The quick-start template also gives you a one-click import to see an agent's skeleton immediately. How to Build an AI Agent with n8n: The Core Workflow The core is a chain of nodes: a trigger wakes the agent, an LLM node reasons, and tool/webhook nodes take action. That's the entire pattern. Here's how to assemble it. Set the trigger Drag a Webhook node onto the canvas if you want the agent called via HTTP, or a Schedule node to run it periodically. For our example, we'll use a webhook that receives a customer question. Add the LLM node Attach an OpenAI Chat Model (or Gemini) node. In the node's parameters, craft a system prompt that scopes the agent. For a support bot, something like: You are a helpful support agent for our SaaS product. Use the tools provided to answer questions. If you don't know, say you need human help. This prompt is the boundary of the agent's autonomy. Keep it specific — vagueness leads to hallucinations. Attach tool and webhook nodes Here's where n8n shines. Drag a Function node to run custom JavaScript (e.g., querying a database) or a HTTP Request node to call an external API. Wire them as "tools" by connecting them to the LLM node's tool output. In the LLM node

I spent the last few months building a Chrome extension that detects HTML code blocks inside ChatGPT, Claude, and Gemini and lets you deploy them straight to a live URL. The "deploy" part turned out to be the easy 20%. The hard 80% was reliably watching three completely different, constantly-changing chat UIs without breaking every other week. Here's what actually taught me something. 1. MutationObserver is non-negotiable, but it will still lie to you None of these chat apps render the full response at once — they stream tokens in, which means the DOM you're watching is incomplete almost every time your observer fires. My first version tried to detect a finished <pre><code> block the moment it appeared. Result: I was grabbing HTML mid-stream, cut off halfway through a <div> . What actually worked was debouncing on DOM stability instead of DOM presence: let debounceTimer ; const observer = new MutationObserver (() => { clearTimeout ( debounceTimer ); debounceTimer = setTimeout ( scanForCodeBlocks , 600 ); }); observer . observe ( document . body , { childList : true , subtree : true }); 600ms of "nothing changed" turned out to be a much more reliable signal than "the tag now exists." Not elegant, but it works across all three sites' streaming speeds. 2. Every AI chat UI restructures its DOM without telling you ChatGPT, Claude, and Gemini all ship frequent frontend updates, and none of them are obligated to keep a stable class name for you to hook into. I initially selected code blocks by class name ( .language-html , .hljs , etc.) and had selectors silently break in production within two weeks of launch. What's held up better: matching on structural patterns instead of class names — a <pre> containing a <code> whose text content starts with <!DOCTYPE or <html . It's slower to write the first time, but it doesn't care what CSS class the framework decided to use this month. 3. "Detect the code" is easy. "Detect the right code" is the actual problem A single AI response

# 🐛 The Bug That Made Me Stop Blaming Python "The computer wasn't confused. I was." I still remember the moment. I had just started learning Python. Every new concept felt exciting. Every successful program made me believe I was getting closer to becoming a real developer. Then I met my first bug. It wasn't a complicated algorithm. It wasn't artificial intelligence. It wasn't even a project. It was a simple countdown. "Print the numbers from 5 to 1." That sounded easy enough. So I wrote this: count = 5 while count > 0 : print ( count ) I pressed Run . For a split second, everything looked normal. Then the terminal kept printing. 5 5 5 5 5 5 ... It never stopped. My first thought was that VS Code had frozen. Then I wondered if Python was broken. Maybe I'd installed something incorrectly. Maybe my laptop was the problem. I restarted everything. Nothing changed. Finally, I stopped blaming the tools and started reading my own code. That's when I noticed something embarrassingly simple. I was asking Python the same question over and over again: Is count greater than zero? The answer was always yes . Because I had never told Python to change count . Not once. The computer wasn't making a mistake. It was following my instructions perfectly. The fix took one line. count = 5 while count > 0 : print ( count ) count -= 1 I ran it again. 5 4 3 2 1 Done. One line. One lesson I'll probably never forget. That day changed how I think about programming. Before, I believed debugging meant finding what the computer had done wrong. Now I know debugging usually means discovering what I told the computer to do. Computers don't guess. They don't assume. They don't fill in missing logic. They execute instructions exactly as they're written. If the result is wrong, the first place I look isn't Python anymore. It's my own thinking. I'm still a beginner, and I know much harder bugs are waiting for me. But strangely, I'm looking forward to them. Because every bug teaches something that no tuto

The Idea: Hidden Instructions Inside Trusted Content Prompt injection is an attack where malicious instructions are embedded inside content that an AI is asked to process - a document, a webpage, an email, a customer support ticket. The model can't always distinguish between "data I'm reading" and "commands I should follow," so it follows the embedded instruction as if a legitimate user sent it. This gets sharper when AI agents (autonomous systems that browse the web, read files, and take actions on your behalf) are involved. A summarizer that reads a webpage might encounter hidden text instructing it to forward your conversation history somewhere, or change the tone of its next reply, or deny remembering something it just said. The model has no inherent way to verify who is actually giving orders. The core problem is one of trust boundaries: current large language models process instructions and data through the same channel - natural language - so there's no hard technical wall between "read this" and "do this." Researchers have demonstrated this across multiple major models, not because any one model is uniquely broken, but because the architecture makes the distinction genuinely difficult. Defenses exist but are imperfect. Techniques include output filtering, sandboxing agent permissions (limiting what actions the model is allowed to take regardless of what it's told), prompt hardening (structuring system prompts to be resistant to override), and retrieval-aware design that treats external content as untrusted by default. No single fix closes the gap entirely. Real Example: The Customer Support Agent Imagine a small business deploys an AI agent to handle incoming support emails. The agent reads the email, checks order history, and drafts replies. A bad actor sends a support ticket that looks normal on the surface, but contains a hidden paragraph - white text on white background, or text in a section the agent processes but doesn't display - that says: "Ignore pr

Parallel Routes let you render multiple pages simultaneously within the same layout. Instead of navigating away from a page to show another one, you can display both at the same time — a dashboard with independently navigable sections, a main content area alongside a sidebar that changes with its own navigation, or a feed with an openable detail panel that doesn't replace the feed. This is one of the more powerful App Router features and one of the more confusing to set up initially. Here's the complete pattern, including the design approach used for complex multi-panel interfaces like the generation tool at Pixova . The Core Concept — Named Slots Parallel routes use named slots: special folders prefixed with @ that define independent rendering areas within a layout. app/ ├── layout.tsx ← Receives slot props ├── page.tsx ← Default slot content ├── @sidebar/ │ ├── page.tsx ← Sidebar default │ └── settings/ │ └── page.tsx ← Sidebar settings view └── @modal/ ├── page.tsx ← Modal default (null) └── photo/[id]/ └── page.tsx ← Photo modal The layout receives each slot as a prop: // app/layout.tsx export default function Layout ({ children , sidebar , modal , }: { children : React . ReactNode ; sidebar : React . ReactNode ; modal : React . ReactNode ; }) { return ( < div className = "flex h-screen" > < aside className = "w-64 border-r" > { sidebar } </ aside > < main className = "flex-1" > { children } </ main > { modal } </ div > ); } Now children , sidebar , and modal can each navigate independently. Independent Navigation — The Key Behavior Each parallel route slot navigates independently. When a user navigates from / to /settings , the children slot updates. The sidebar slot stays exactly where it was — its navigation state is independent. This is the key difference from nested layouts. Nested layouts rerender from the changed segment outward. Parallel routes don't affect each other. User is at / (children shows home, sidebar shows default nav) User navigates to /setti

Repo: https://github.com/voku/agent-loop Demo: https://voku.github.io/agent_loop_demo/ Your Coding Agent Doesn’t Need More Memory. It Needs a Governed Loop. Coding agents repeat mistakes. The obvious response is to give them more memory: MEMORY.md project-rules.md agent-notes.md lessons-learned.md MEMORY_FINAL.md Soon the agent receives old decisions, temporary workarounds, copied transcripts, abandoned ideas, and rules nobody remembers approving. It has more context. It does not necessarily have better context. At some point, memory becomes landfill. The problem is not that coding agents forget too much. The problem is that most workflows fail to distinguish between temporary context, evidence, proposed learning, and approved project guidance. A transcript is not memory. A note is not a rule. A finding is not guidance. And a successful patch is not automatically a project convention. Instead of giving the agent one growing pile of context, I built voku/agent-loop around a governed workflow: task -> approved plan -> selective recall -> implementation -> verification -> recorded evidence -> reviewed learning Start with approved scope A coding agent should not begin by reading a ticket and creatively filling in everything the ticket forgot to mention. It should begin with an explicit work brief: goal; permitted scope; non-goals; affected files; required validation; human approval. For example: vendor/bin/agent-loop workflow plan PROJECT-123 \ --by lars \ --learning-root infra/doc/agent-learning \ --file src/Order/OrderService.php \ --file tests/Order/OrderServiceTest.php \ --goal "Reject invalid order state transitions" \ --scope "Order state validation and its tests" \ --non-goal "Do not redesign the order aggregate" \ --validate "composer phpstan" \ --validate "composer test" A human then approves that specific revision: vendor/bin/agent-loop workflow approve PROJECT-123 --by lars When the plan changes, the old revision becomes superseded , and the new one requires

Google DeepMind and Isomorphic Labs are sharing our joint approach to bioresilience and AI models.

Working late nights on server migrations and code architectures often means typing in low-light environments. While USB lamps or backlit keyboards are the standard solutions, they consume extra power and add physical clutter. I realized the ultimate light source was already directly in front of me: the monitor. With a clear vision in mind, I partnered with Google's Gemini AI to rapidly prototype and refine what became LightBar For Keyboard , a lightweight Windows application that creates a reflective light bar at the bottom of the screen to illuminate the keys. Here is how we built it using C# and WPF, tackled the Windows API to manage screen space, and optimized it for modern OLED energy consumption. The Core Challenge: Desktop Toolbars (AppBar) The simplest approach to creating a light bar is a borderless, top-most window. However, the immediate UX flaw is that maximized applications (like Chrome or Visual Studio) will either cover the bar or be partially obscured by it. To solve this, the application needed to behave like the Windows Taskbar. I implemented the native Windows Application Desktop Toolbar (AppBar) API using SHAppBarMessage from shell32.dll . Docked Mode: By registering the application as an AppBar and setting the edge to ABE_BOTTOM , Windows automatically recalculates the working area of the desktop. Result: Maximized windows are pushed upward, ensuring the light bar remains entirely visible and never covers any underlying application UI. Floating Mode: For users who need temporary access to the bottom of their screen, I added a state toggle that unregisters the AppBar and enables standard drag-and-drop window movement via MouseLeftButtonDown . Enforcing a Single Instance Because the app directly manipulates the desktop working area, launching multiple overlapping instances would cause UI glitches. To prevent this, I implemented a Mutex in App.xaml.cs to guarantee a single instance constraint. protected override void OnStartup ( StartupEventArgs e )

Instant, hardware Isolated Sandboxes for AI agents Discussion | Link