标签：#ai

When we build something complex—whether it’s a skyscraper, a gourmet meal, or a piece of software—we usually start with a plan. In software development, however, it’s easy to skip that step. We often jump straight into implementation, focusing on how to write the code instead of the intent behind it. Over time, this leads to rework, confusion, and systems that don't quite match our original goals. Spec-Driven Development (SDD) is an approach that shifts the focus back to the plan. Instead of starting with code, you start with a Specification : a clear, structured description of what the software should do. You then use an AI coding agent as a high-speed collaborator to help turn that specification into working code. 🔍 What is a “Spec”? A Specification (or “Spec”) is a written contract between your intention and the final product. It isn't a 50-page manual; it's a living document that defines: What the system should do. How it should behave in different scenarios. Which constraints and rules it must follow. From Prompts to Specifications There is a massive difference between a vague prompt and a structured spec. Loose prompts often lead to inconsistent results and "hallucinations," whereas clear specifications give the AI a much better target to hit. Bad Prompt: > “Build me a login system.” Good Spec: A good spec provides the clarity an AI (or a human) needs to succeed. You don’t need a 10-page document to benefit from specs; you need clarity, not length. 🛠️ Example Spec: Login Endpoint Overview Allow users to log in using email and password. Endpoint POST /api/login Request { "email" : "user@example.com" , "password" : "string" } Behavior Success: If email and password are correct → return a token and user info. Invalid Credentials: If credentials don't match → return INVALID_CREDENTIALS . Invalid Input: If fields are empty or the email format is wrong → return INVALID_INPUT . Rules Passwords must be stored hashed (e.g., bcrypt). Token expires in 24 hours. Security:

"# The AI Cost Crisis: How Startups Can Survive the Tokenpocalypse\n\n## Introduction\n\nThe artificial intelligence boom has brought unprecedented innovation, but it has also ushered in a era of spiraling costs. Training state-of-the-art models now requires millions of dollars in compute resources, while simultaneously, the cryptocurrency token market shows signs of a potential collapse—a \"Tokenpocalypse.\" For AI startups, this dual crisis presents an existential threat: how to sustain innovation when both traditional funding avenues and speculative token economies are under pressure? This post explores practical strategies for AI startups to navigate this landscape, focusing on cost optimization, alternative funding, and strategic pivots that can turn crisis into opportunity.\n\n## Understanding the Cost Explosion\n\n### The Compute Crunch\n\nModern AI models, particularly large language models (LLMs) and multimodal systems, demand vast computational resources. Training a single cutting-edge model can consume exaflops of processing power, translating to cloud bills that easily exceed $10 million for a single training run. For startups without deep-pocketed backers, these costs are prohibitive.\n\n### The Token Market Volatility\n\nParallel to the AI boom, the cryptocurrency space experienced explosive growth through token launches—initial coin offerings (ICOs), decentralized finance (DeFi) tokens, and utility tokens for AI-driven projects. However, regulatory crackdowns, market saturation, and declining investor sentiment have led to a sharp downturn. Many tokens have lost significant value, and launching new tokens has become increasingly difficult, removing a once-viable funding path for AI startups.\n\n## Strategies for Survival\n\n### 1. Embrace Model Efficiency\n\nInstead of chasing ever-larger models, startups can focus on efficiency techniques that deliver comparable performance at a fraction of the cost:\n\n- Model Distillation : Train smaller \"student\

Google says Gemma 4 12B is "designed to bring agentic, multimodal intelligence directly to your laptop", further noting that the new model can be combined with Google AI Edge to "build and experiment locally, on everyday machines". This integration allows for a wide range of capabilities, from autonomous data processing to generating visual insights and even building webpages or executing tools. By Sergio De Simone

InfoQ celebrates its 20th anniversary. To mark the occasion, we have published a walk-through of the trends InfoQ called early, where they sit on the adoption curve today, and how that curve may evolve over the next decade. By InfoQ

Machine learning has its limits—how is it being used?

Birgitta Böckeler, Distinguished Engineer at Thoughtworks, returns to discuss the rapid evolution of AI in software delivery. She touches on the evolution from vibe coding, the changing tools landscape and the more autonomous agents that, besides higher velocity, introduce higher risk. By Birgitta Böckeler

In this article, the author examines how AI is transforming phishing from a manual, targeted activity into an automated and scalable attack model. The article breaks down each stage of the phishing lifecycle, showing how AI improves reconnaissance, profiling, content generation, delivery, and interaction, while outlining layered defenses that combine controls, processes, and user awareness. By Marco Rizzi

Apple's biggest event of the year is nearly here. The company's Worldwide Developers Conference will spotlight updates to iOS, macOS, and all of Apple's other operating systems, and this year's event could also include a major overhaul for Siri. Here's how you can watch along live. When WWDC will happen and where you can watch […]

A compliance team at a mid-size bank in Abu Dhabi processes new customer applications every week....

While vibecoding, you sometimes need some background music. But music can also be a massive...

I ran a 4-bit medical-triage model on a laptop GPU and on a CPU. For one patient, the GPU said urgent and the CPU said emergency. Same model file, same prompt, same input. Here's the mechanism and why "validated on hardware X" doesn't mean what you'd hope. I've been building Aegis-MD , a local-first emergency-department triage console. You hand it a structured clinical picture: chief complaint, vitals, age, pain score, a few risk modifiers, and it returns an urgency category on the Australasian Triage Scale (ATS 1–5), where ATS-1 means resuscitate now and ATS-5 means this can wait two hours . The whole thing runs on-device: a quantized MedGemma 4B served through Ollama, a small RAG layer over open guidelines, and a deterministic rule-based floor underneath the model. I never set out to write about floating-point arithmetic. But while running my evaluation set across two machines, I hit a result that stopped me, and the explanation turned out to be more interesting and more current than the textbook answer most people reach for. The setup, and why a 4-bit model Two things about Aegis-MD's design matter for this story. First, it's local by design. Triage data is about as sensitive as data gets, so nothing leaves the machine. The trade-off is that I'm running a small, heavily quantized model: MedGemma 1.5 4B at Q4_K_XL , about 3.4 GB rather than a frontier API. Four-bit weights are the price of running offline on consumer hardware. Second, I tested on two configurations on purpose. The intended deployment is local GPU inference (an RTX 5070 Ti Mobile, 12 GB). But the public demo runs CPU-only on Cloud Run, because GPU instances need a paid quota I don't have. So I ran the same evaluation against both: the GPU build and the CPU build, same model, same code, same prompts. The eval is 17 hand-written cases spanning all five ATS levels, cardiac arrest down to a medical-certificate request. (Seventeen is a smoke test, not a validation; I won't quote a percentage off a sampl

Key takeaways Give an AI agent live web data by connecting it to Crawlora's hosted MCP endpoint — it calls documented tools (search, maps, commerce, social, finance) and gets normalized JSON back, with no scraping code or proxies to run. MCP (Model Context Protocol) is an open standard: agents discover and call tools through one interface instead of a bespoke integration per data source. Connect over Streamable HTTP at https://mcp.crawlora.net/mcp with your API key — about three minutes in Claude, Cursor, Cline, Windsurf, or any MCP client. One connection exposes 319 tools across 33 platforms (393 REST endpoints underneath): Google/Bing/Brave search, Google Maps, Amazon, YouTube, TikTok, Yahoo Finance, CoinGecko, and more. You pay only on a successful (2xx) response — failed calls are free — and the free tier includes 2,000 credits a month with no card. Versus writing your own scrapers: no per-source glue code, normalized JSON instead of HTML, and proxy routing, rendering, and retries handled behind the endpoint. You can give an AI agent live web data by connecting it to a hosted MCP endpoint : your agent calls documented tools — search, maps, e-commerce, app stores, social, finance, and more — and gets back normalized JSON, with no scraping code to write or proxies to run. This guide explains what MCP is, what data you can pull, how to connect in about three minutes, and what a real tool call and its response look like. Most LLMs are frozen at their training cutoff and can't see the live web. The usual fix — writing a scraper per source, then maintaining proxies, headless browsers, and parsers — is exactly the work teams don't want to own. MCP plus a hosted data server removes it: the model gets a stable set of tools, and the fetching lives behind an endpoint. What is MCP, and why does it matter for agents? The Model Context Protocol (MCP) is an open standard that lets an AI agent call external tools through one consistent interface. Instead of wiring a bespoke int

The AI landscape is evolving faster than ever. Keeping track of the right tools can feel like trying to drink from a firehose. I recently dug through my extensive bookmarks folders and compiled every single AI tool and Autonomous Agent I've saved. Whether you're looking for an autonomous coding agent, a rapid app builder, an LLM benchmark, or a creative suite, you need the right tool for the job. Bookmark this page, because you're going to want to refer back to it. Superdesign Maskara.ai Google Labs: Google's home for AI experiments - Google Labs Kilo Code - Open source AI agent VS Code extension hunyuan bolt.new Rocket.new | Build Web & Mobile Apps 10x Faster Without Code AI Web Scraping Extension | Chat4Data Sarvam AI Lovable Starc- film ShumerPrompt aipai.app Flowe MiniMax Official Website - Intelligence with everyone new.website | Build Websites with AI Higgsfield HeyBoss.ai Mitte Trickle AI - Turn your ideas into live apps and websites with AI. Dora: Start with AI, ship 3D animated websites without code Kimi AI – Think Bigger. Search Smarter. Write Better. a0.dev - Create Mobile Apps with AI sesame Vogent - Create AI Voice Agents Orchids - Make something beautiful Same PromptBase | Prompt Marketplace: Midjourney, ChatGPT, Sora, FLUX & more. LM Studio Mindstone Chat with Z.ai - Free AI for Presentations, Writing & Coding AI Model & API Providers Analysis | Artificial Analysis T3 Chat - Advanced AI Assistant & ChatGPT Alternative | $8/month Poe Freepik | All-in-One AI Creative Suite Replit – Build apps and sites with AI unwind ai Magic Patterns Soapbox - Build Your Decentralized Platform Shakespeare - AI Website Builder AI recruitment engine to hire top global talent | micro1 Ponder AI | New Way to Work with Knowledge Using AI Ask AI Questions · Question AI Search Engine · iAsk is a Free Answer Engine - Ask AI for Homework Help and Question AI for Research Assistance Firecrawl Kiro: The AI IDE for prototype to production Le Chat CodeArena – Which LLM codes best?

I Built a GDPR Compliance Scanner Using the Claude API - Here's How It Works A few months ago I noticed something that kept bugging me. I was building and handing off websites for clients and every single time, GDPR compliance was either an afterthought or a panic right before launch. Privacy policies copied from templates, cookie banners slapped on at the last minute, no one really sure if the contact form was actually compliant. The bigger problem: there was no quick, affordable way to check . Enterprise compliance tools cost hundreds per month. Legal consultants cost more. Most small businesses just crossed their fingers. So I built ClearlyCompliant - an automated GDPR compliance scanner that analyses a website and delivers a detailed PDF report for a one-off fee. No subscription, no jargon, just a clear picture of where a site stands. Here's how it actually works under the hood. The Stack Django (Python) - backend and web app BeautifulSoup + requests - crawling and HTML parsing Python threading - async scanning without the overhead of Celery/Redis Anthropic Claude API (Haiku) - AI-powered policy analysis ReportLab - PDF report generation Stripe - payments IONOS SMTP - email delivery Gunicorn + Nginx on an IONOS VPS The Scanning Pipeline When a user submits a domain and completes payment, the scan kicks off immediately. Rather than making them wait on a loading screen, the scan runs asynchronously in a background thread and the report gets emailed when it's done. I deliberately avoided Celery and Redis here. For the scale I needed, Python's built-in threading module was more than sufficient and kept the infrastructure simple. One less thing to maintain, one less thing to break. import threading def run_scan_async ( domain , order_id , customer_email ): thread = threading . Thread ( target = run_full_scan , args = ( domain , order_id , customer_email ) ) thread . daemon = True thread . start () The scan itself runs 23 individual GDPR checks across several categori

TL;DR: I built PackagePal — paste in any package from any language, pick your target language, and AI instantly finds the equivalent. No more Googling "what's the Node.js version of Python's requests ?" The Problem That Drove Me Crazy You know that moment when you're migrating a project — or just jumping between ecosystems — and you hit a wall trying to find the right package? I do. Every time. # You're used to this in Python import requests response = requests . get ( " https://api.example.com/data " ) And you move to Node.js and think: "Okay, what do I use here? axios? node-fetch? got? undici?" So you Google it. You find a Stack Overflow thread from 2019. Half the answers recommend packages that are now deprecated. You open 6 tabs. 20 minutes later you're still not sure which one is the current best choice. This wasn't a once-in-a-while thing for me. It happened constantly — switching between Python, JavaScript, Go, and Ruby on different projects. I was wasting real hours on a problem that felt completely solvable. So I built PackagePal . What PackagePal Does PackagePal uses AI to understand what a package actually does — its purpose, not just its name — and finds the best equivalent in whatever language you're moving to. The key insight: this isn't a lookup table. A simple mapping of requests → axios misses context. What if you're using requests for its session management? Or its retry logic? PackagePal surfaces options and explains why each one is a good match. Example searches people use it for: Python's pandas → JavaScript Ruby's devise → Node.js Go's cobra → Python JavaScript's lodash → Go Just type the package, pick the target language, and get results in seconds. 👉 Try it: packagepal.dev How I Built It Tech Stack 🤖 AI: Gemini Pro — handles the semantic understanding of what a package does and why an alternative matches ⚛️ Frontend: React + TypeScript ⚙️ Backend: Node.js + TypeScript on Google Cloud ⚡ Caching: Redis — so repeat searches (e.g., "requests → No

Everyone's writing specs for AI now. We hand the model a markdown file, tell it what we want, and hope it builds the right thing. It mostly works — until it doesn't. Markdown has quietly become the spec language. People reach for it as the DSL for their AI-driven workflows — headings, bullet lists, the odd table — and treat that loose structure as if it were a contract. The thing is, it isn't a DSL. It's markdown. It's prose formatting with no grammar to enforce, no structure you can execute, no shared vocabulary, and no way to tell whether the spec and the code still agree. You're leaning on a document format to do a job it was never built for, and you hit the limit the moment you want the spec to actually mean something a machine can check. Before you go down that road, I want to make a small, slightly absurd suggestion. Eat a cucumber. What I actually mean Gherkin is the plain-text language behind Cucumber , a tool that's been around for years in the behavior-driven development (BDD) world. It looks like this: Feature : User login Scenario : Successful login with valid credentials Given a registered user "ada@example.com" When she logs in with the correct password Then she should land on her dashboard And she should see a welcome message Scenario : Rejected login with wrong password Given a registered user "ada@example.com" When she logs in with an incorrect password Then she should see an "invalid credentials" error And she should remain on the login page That's it. Feature , Scenario , Given / When / Then . Structured enough that a machine can parse it, loose enough that a product manager can write it. The gap it bridges Most specs live at one of two extremes. On one end you have written specs : docs, tickets, markdown files. Readable by anyone, but inert. Nothing checks whether they're still true. They rot the moment the code moves on. On the other end you have tests : precise, executable, always honest — but written in code, illegible to half the people who a

title: Your AI Agent Should Not Be Locked to One LLM Provider published: false description: Why serious AI agents need a provider-agnostic architecture, model routing, fallback, and a unified API gateway. tags: ai, llm, agents, architecture Your AI Agent Should Not Be Locked to One LLM Provider Most AI agent prototypes start the same way. You pick one model provider. You install one SDK. You write a few prompts. You add tool calling. You build a demo. It works. Until it does not. The moment you want to try another model, reduce cost, add fallback, improve latency, or support different task types, your simple agent starts turning into a messy collection of provider-specific logic. That is when you realize something important: A real AI agent should not be locked to one LLM provider. If you are building a personal AI agent, coding assistant, research assistant, internal workflow agent, or AI-native product, the model should be replaceable infrastructure — not a hardcoded dependency. The Problem with Single-Provider Agents A simple agent architecture often looks like this: CopyUser ↓ Agent ↓ One LLM Provider ↓ Response This is fine for a proof of concept. But real-world agent systems need more flexibility. Different tasks often need different models: Task Better Model Strategy Quick summarization Fast, low-cost model Complex coding Strong coding model Long document analysis Long-context model Reasoning-heavy planning Reasoning model Multilingual writing Model strong in that language Background automation Cheap and reliable model Production fallback Backup provider If your agent is deeply coupled to one provider, every optimization becomes harder. You cannot easily answer questions like: What happens if the provider is down? What if latency spikes? What if another model is cheaper for simple tasks? What if a new model is better for coding? What if a user wants Claude for writing but GPT for structured reasoning? What if you want to route Chinese tasks to a different mod

Three weeks ago, one of the teams we work with had a checkout outage. The root cause a malformed...

Microsoft announced the general availability of Microsoft Discovery, its Azure-based platform for deploying autonomous AI agent teams in scientific R&D. The platform powered the development of Majorana 2, a topological quantum chip with 1,000x reliability improvement and 20-second qubit lifetimes. Microsoft now targets a scalable quantum computer by 2029, halving its original timeline. By Steef-Jan Wiggers

Today, June 8th, InfoQ celebrates 20 years. This is not a comprehensive history, but a deliberately selective look at the technologies and practices InfoQ identified early, where they sit on the adoption curve in 2026, and how that curve may evolve over the next five to ten years. By InfoQ