标签：#ai

Just a few days after pushing Fable out of 2026, Microsoft showed off more footage of Fable, the first new entry in the storied RPG franchise since 2010's Fable III, at its Xbox Games Showcase on Sunday. The company also announced a specific release date: February 23rd, 2027. Though if you get the Premium Edition, […]

As part of its Xbox Games Showcase on Sunday, Microsoft revealed new details about Halo: Campaign Evolved, the upcoming remake of Halo: Combat Evolved's campaign mode. The remake will debut on Xbox Series S / X, PC, and PS5 on July 28th. Today's mission trailer includes a first look at Operation: Meteorite, a new three-mission […]

Apparently, the "return of Xbox" means a retreat from other platforms. At its Xbox Games Showcase today, Microsoft revealed that Gears of War: E-Day - which was previously rumored for a PS5 launch in addition to Xbox and PC - will not be coming to PlayStation. It'll be an Xbox console exclusive and is launching […]

Have you ever wondered what the most indispensable app is for your favorite musician or how the world’s tech CEOs stay focused? Well, that’s the sort of thing we aim to uncover in our Verge Weekend Questionnaire. Think of it as a spiritual successor to Five Minutes on the Verge. Every Saturday, a different guest […]

The console industry is in a weird place, and both Xbox and PlayStation have a chance to change the narrative a bit with their showcases at Summer Game Fest. Sony did that by focusing on the single-player titles it’s known for, and then it was Microsoft’s turn. The Xbox Games Showcase was focused mainly on […]

"Chat is dead" — at least, according to a senior OpenAI employee.

The revamped AI tool will roll out in the coming weeks, according to The Financial Times.

I built something I desperately needed: daily AI audio lessons from real developer trends (plus a Dutch coach for inburgering B1). The hardest part wasn't the AI. It was figuring out how to score genuine rising skills vs. one-day noise. I ended up building a cross-day momentum signal that rewards skills accelerating over 3+ days and dampers spikes. But I'm stuck on the next problem: how do you personalize this without storing user data? (I'm privacy-first, so no subscriber DB — Telegram holds the member list.) If you've solved this, I'd love your take. And if you're learning Dutch + coding, I'd appreciate you trying it and telling me what's useless. What I'm curious about: Is the momentum signal actually working — am I surfacing real trends or just noise? Would the Dutch coach be useful for expat developers in NL, or is it too niche? Technical details (for those who care): • 7 sources: GitHub Trending, HN (Who-is-Hiring + front page), Stack Overflow tag deltas, dev.to, Reddit, Lobste.rs • Map-reduce skill extraction with deterministic attribution (corpus scan, not LLM tally) • Grounded briefs: reads actual source text via Jina + Exa, cited sources • Delivered via Telegram (audio + PDF), Spotify podcast, email • Privacy: PII redacted at ingestion, no subscriber data stored Live: https://yusuprozimemet.github.io/LearnX-Radar/ GitHub: https://github.com/Yusuprozimemet/LearnX-Radar (P.S. This is still beta — I'm looking for feedback, not users. If you try it, tell me what's useless, not what's good.)

This is a submission for the GitHub Finish-Up-A-Thon Challenge What I Built SpendWise AI is a free tool that audits your AI tool spending (Cursor, Copilot, Claude, ChatGPT, Gemini, Windsurf) against verified vendor pricing and tells you exactly where you're overspending and what to do about it. I originally built this as a week-long assignment for a startup. The problem it solves is simple: founders and engineering managers pay for multiple AI tools but have no idea if they're getting ripped off. SpendWise gives them that answer in under a minute, no signup needed. The interesting part is that the core audit engine has zero AI in it. It runs 6 hardcoded rules against verified pricing data, so every recommendation is reproducible and verifiable. AI (Groq's Llama 3) only kicks in to write a friendly summary paragraph on top of the structured results. I made this choice because financial recommendations need to be deterministic. Same input, same output, every time. The stack is Next.js 16, TypeScript, Tailwind + shadcn/ui, Supabase for the database, Groq for AI summaries, Resend for emails, and Vitest for testing. Deployed on Vercel. Live app: spendwise-ai-test.vercel.app Source code: github.com/Karam-999/SpendWise-AI Demo The original audit tool: The comeback (re-audit on pricing change): You can try the Round 1 version live at spendwise-ai-test.vercel.app . Pick a tool like Cursor on Teams plan at $40/mo, run the audit, and see the full savings breakdown. The Round 2 features (pricing change detection, re-audit diff view) are on a separate branch and not merged to main yet, but the demo video above walks through the complete flow. The Comeback Story Where it was: The original version was basically a calculator. You fill in your AI tools, it shows you where you can save money, and that's it. If Cursor changed its pricing the next week, your audit was already stale and you'd never know about it. It worked fine as a one-time thing. It had the form, the audit engine, AI

Most side projects start with a simple frustration. Mine started with a banking app. One of my banks had a feature I really liked. It automatically categorized transactions and showed spending breakdowns in graphs and charts. For the first time, I could easily see how much I spent on restaurants, groceries, transport, subscriptions, and other categories. The problem was that only one of my banks offered this feature. Like many people, I use multiple bank accounts, credit cards, and savings accounts. Two of my other banks provided little more than a long list of transactions. If I wanted a complete picture of my finances, I had to switch between apps and manually piece everything together. As a software engineer, my first instinct was obvious: "Why don't I just build this myself?" That idea eventually became MyVault . The Original Goal The first version of the project was surprisingly simple. I wanted users to: Upload bank statements Extract transaction data Automatically categorize spending View useful charts and reports The goal wasn't budgeting. It wasn't investment tracking. It wasn't accounting. I simply wanted a single place where I could see spending across all of my bank accounts. Once I started building, however, I realized there was a much more interesting opportunity. If all transaction data was already extracted and structured, why not allow users to ask questions about their finances? Instead of searching through transactions manually, users could simply ask: How much did I spend on restaurants last year? What subscriptions am I paying for? Which categories increased the most this month? How much did I spend while traveling? That's when MyVault started evolving from a reporting tool into an AI-powered financial assistant. Building as a Solo Developer One of the biggest challenges wasn't technology. It was building everything alone. When you're working on a side project, you don't just write code. You become responsible for everything: Product decisions B

I'll give the usual caveat: The horror novel Japanese Gothic is best experienced going in with as little information as possible. Content warnings for graphic gore, scenes of domestic violence, self-harm, and mental illness. If you're okay with that, then consider pausing here. While I will try to keep this relatively spoiler-free, there will be […]

Constantly being plugged into the news grind is mentally exhausting. Sometimes we just need to take a break, unwind, and do something fun. That’s why we’ve built up a collection of distracting time-wasters for when we need a break from being obsessively online. We figured you might enjoy these harmless rabbit holes, mildly addictive browser […]

I maintain an open-source GitHub Action called vorsken. It does one thing: scan the diff on a pull request with Semgrep, apply a fixed policy, and return BLOCK, FLAG, or PASS. No dashboard, no model that drifts over time. Rules at ERROR/HIGH/CRITICAL severity block the merge, WARNING/MEDIUM flag it, the rest pass. Same diff, same verdict. The usual pitch for a tool like this is that it catches the SQL injection your AI assistant wrote. I wanted to see what it actually catches against real assistant output, so I generated 28 functions and ran them through. The test Seven backend tasks: a FastAPI upload endpoint, a URL-fetch helper, JWT auth, a SQL filter, an ImageMagick subprocess call, a LangChain file agent, and a LangChain RAG pipeline. I generated each one four times, with ChatGPT (GPT-5.5 Instant), Claude Code (Opus 4.8), Claude Code plus the security-guidance plugin, and Cursor (Composer 2.5). Single-shot, neutral prompt, no security hints. Then I scanned all 28 with the same ruleset. I'm reporting which rule fired on which file, not whether some model thinks the code is safe. That part you can reproduce. Task ChatGPT Claude Code + plugin Cursor Verdict file upload — — — — PASS url fetch (SSRF) ssrf ssrf ssrf — FLAG / Cursor PASS jwt auth api8 api8 — — BLOCK / 2 PASS sql filter — — — — PASS imagemagick — — — — PASS fs agent — overperm — — 1 BLOCK / 3 PASS rag dangerous dangerous dangerous dangerous BLOCK 7 BLOCK, 3 FLAG, 18 PASS across 28 functions. The basics were fine SQL filter, ImageMagick, file upload: clean on every tool. The SQL was parameterized, the subprocess calls passed argument lists instead of shell strings, the uploads weren't doing anything reckless. If you still expect current models to spray SQL injection across a straightforward CRUD task, they don't. On conventional work they get it right. Two of the flags are soft. The JWT api8 hits landed on a SECRET_KEY = "CHANGE_ME" placeholder, which you can read as a false positive or as a gate doing i

Multi-Model AI API Routing: Cut Costs Without Sacrificing Quality Problem: You're building an AI-powered app, but relying on a single model (like GPT-4) for every request is burning through your budget. Simple tasks like summarization or classification don't need a heavyweight model, yet you're paying premium prices for them. Solution: Route requests intelligently to the cheapest model that can handle each task. This is multi-model AI API routing, and it can cut your costs by 60-80% while maintaining output quality. Prerequisites Python 3.8+ API keys for at least 2 AI providers (e.g., OpenAI, Anthropic, or NovaAPI) Basic understanding of async/await in Python Step 1: Define Your Routing Strategy First, create a routing configuration that maps task complexity to model tiers: # router_config.py ROUTING_CONFIG = { " simple " : { " models " : [ " nova-1-fast " , " gpt-3.5-turbo " ], " cost_per_token " : 0.0001 , " max_tokens " : 500 , " tasks " : [ " summarization " , " classification " , " entity_extraction " ] }, " medium " : { " models " : [ " nova-1-medium " , " gpt-4-mini " ], " cost_per_token " : 0.0005 , " max_tokens " : 2000 , " tasks " : [ " code_generation " , " translation " , " sentiment_analysis " ] }, " complex " : { " models " : [ " nova-1-pro " , " gpt-4 " ], " cost_per_token " : 0.002 , " max_tokens " : 4000 , " tasks " : [ " reasoning " , " creative_writing " , " complex_qa " ] } } Step 2: Build the Router Now implement the core routing logic with fallback capabilities: # ai_router.py import asyncio from typing import Dict , List , Optional import time class AIRouter : def __init__ ( self , config : Dict , api_keys : Dict [ str , str ]): self . config = config self . api_keys = api_keys self . metrics = { " cost " : 0 , " requests " : 0 , " failures " : 0 } async def route_request ( self , task : str , prompt : str ) -> str : """ Route request to appropriate model based on task complexity. """ tier = self . _classify_task ( task ) models = self . confi

Over the past few months I built an AI-assisted delivery framework — not to write code faster, but to eliminate ambiguity across the entire software development lifecycle. The result completely changed how I think about AI in engineering. The problem I kept hitting Every time I used AI to generate architecture docs, API contracts, or implementation plans across separate sessions, the outputs looked great in isolation. But viewed together? They were broken. A pivot in the system architecture was never reflected in the API contracts. Frontend assumptions silently diverged from backend data models. AI wasn't the problem. Treating it as a collection of disconnected prompt sessions was. What I built instead A governance-driven framework built on three layers: Prompt → Agent → Skill The Prompt captures intent only — lightweight, declarative The Agent orchestrates execution and decides which capabilities to invoke The Skill is a reusable, schema-validated execution block with hardcoded governance rules This connects every delivery artifact into a sequential dependency chain: Business Requirements ↓ System Architecture ↓ Data Architecture ↓ Event Architecture ↓ API Contracts ↓ Implementation Plans ↓ Backend / Frontend Implementation Each artifact consumes the one before it. Upstream changes automatically propagate downstream. Governance is enforced at the Skill layer — not buried in fragile prompts. The finding that surprised me most The highest-leverage use of AI wasn't code generation. It was context generation . When engineers — or downstream agentic workflows — were given a governed, unambiguous spec, implementation quality was consistently higher than any raw AI-generated code output. The context was the unlock, not the syntax. What failed I'm including this because most write-ups skip it: Over-orchestrating everything (not every workflow needs an agent loop) Prompt bloat as a substitute for real architecture Severely underestimating token costs at scale Believing full

Building a Deterministic Security Scanner for AI-Generated Code TL;DR: I built TruffleKit , a CLI security scanner that catches 22 vulnerability classes in under 2 seconds with zero false positives. Here's how the scanning engine works under the hood. AI code generation is producing more production code than ever. But AI models are trained on public code — which means they reproduce the same security mistakes the open-source ecosystem has been making for decades. In my tests, 73% of AI-generated code snippets contain at least one security vulnerability that a standard linter would completely miss. I couldn't find a tool that was fast, deterministic, and had zero false positives. So I built one. The Architecture The scanner is a rule-based deterministic engine written in Python. Each rule is a self-contained module that pattern-matches against a file's AST or raw content. scanner/ ├── __init__.py ├── engine.py # Orchestrator ├── reporter.py # Output formatting ├── rules/ │ ├── __init__.py │ ├── secret_detection.py │ ├── sql_injection.py │ ├── path_traversal.py │ ├── weak_encryption.py │ ├── cors_misconfig.py │ └── ... (22 rules total) └── models.py Key Design Decisions 1. AST-Based Pattern Matching For languages like Python and JavaScript, we parse the file into an AST and match against structural patterns — not regex. This eliminates false positives from strings that happen to look like code. import ast class SQLInjectionRule ( BaseRule ): def check ( self , tree : ast . AST , filename : str ) -> list [ Finding ]: findings = [] for node in ast . walk ( tree ): # Match: cursor.execute(f"...{variable}...") if isinstance ( node , ast . Call ): func_name = self . _get_call_name ( node ) if func_name in ( ' cursor.execute ' , ' db.execute ' , ' connection.execute ' ): for arg in node . args : if self . _is_f_string_or_concat ( arg ): findings . append ( self . _make_finding ( severity = ' high ' , message = ' SQL injection: parameterized query required ' , line = node .

In the previous article, we explored concepts such as total loss and epochs. Now, we will continue...

This is The Stepback, a weekly newsletter breaking down one essential story from the tech world. For more on AI confusion, follow Robert Hart. The Stepback arrives in our subscribers' inboxes at 8AM ET. Opt in for The Stepback here. How it started At first, AI influencers were relatively easy to identify - and to […]

How accurate does an AI system need to be?

Why RAG needs context judgment, not just better retrieval Most RAG systems optimize for retrieval. That makes sense. Search better. Embed better. Chunk better. Rank better. Fetch more sources. All of that matters. But retrieval alone does not answer a different question: Should this context actually influence the model? That is the problem FreshContext is built around. FreshContext is context judgment infrastructure for AI agents, RAG systems, and retrieval workflows. The simple version: candidate context in decision-ready context out Retrieval is not judgment A retriever usually answers: What might be relevant? A context judgment layer asks: What should happen to this context before it reaches the model? Those are different problems. A source can be relevant but stale. A source can be recent but low-confidence. A source can be useful as background but not strong enough to cite. A source can have no reliable date. A source can be a duplicate. A source can need verification before it should influence an answer. A normal RAG pipeline can retrieve all of that and still pass it straight into the prompt. That is where things get messy. The model may reason fluently from weak context, and the final answer can look confident even when the input material was stale, uncertain, or not citation-grade. The missing layer between retrieval and reasoning FreshContext sits after retrieval and before reasoning. It does not try to replace search, vector databases, RAG frameworks, or agent frameworks. It focuses on the boundary between them and the model. The product spine looks like this: candidate context -> FreshContext Core -> freshness / provenance / confidence / utility / source profile -> decision helper -> decision-ready output -> model / agent / app The goal is not just to produce another score. The goal is to turn candidate context into a decision. Example decisions include: cite_as_primary cite_as_supporting use_as_background needs_refresh needs_verification watch_only excl