WebMCP Spec Update: Consequential Hint Added

🦀⚡ RAHTI First Look: Rust-Powered Frontend + MCP + AI Agents | The Agent-First Web Framework 🤖🔥 🚀 Meet RAHTI — a new Rust-powered web framework built for the next generation of high-performance, AI-driven applications. 🦀⚡ In this first look at Rahti, we explore how the framework brings the power of Rust to modern full-stack web development while keeping the frontend simple, reactive, component-based, and incredibly close to the browser. 🌐🔥 Rahti takes a different approach: 🦀 Rust-Powered Full Stack Build your application, server logic, routing, components, RPCs, authentication, WebSockets, and more around the Rust ecosystem. ⚡ Performance-First Architecture Server-render real HTML, compile your application into a native binary, and avoid the traditional Node.js + bundler + JavaScript build pipeline. 🧩 Rahti Components Create reusable components as ordinary Rust functions and even distribute complete component libraries through crates.io. 🎨 Rahti Icons Install individual SVG icon components directly into your project: cargo rahti-icons add user No massive icon package required. Add what you need and keep your application clean. ✨ 📁 File-System Routing Pages, layouts, dynamic routes, catch-all routes, loading states, error boundaries and API routes follow predictable project conventions. ⚙️ Server Functions with Typed RPC Place your server functionality beside your UI using #[rpc] and call Rust functions directly from the frontend through Rahti's RPC layer. 🔌 WebSockets Ready Need real-time communication? Rahti provides optional native WebSocket support for interactive and event-driven applications. 🤖 AGENT-FIRST BY DESIGN This is where Rahti gets especially interesting. Rahti projects are structured so coding agents can actually understand the framework and the application they are modifying. Projects can include: 📚 AGENTS.md 📑 Framework convention documentation 🧠 Agent-readable architecture rules 🔎 Structured development diagnostics 🛠️ Predictable project conventions 🔌 MCP integration Rahti even provides a dedicated Model Context Protocol server, giving MCP-compatible AI clients structured visibility into the application, its configuration, conventions, database artifacts and development diagnostics. That means instead of forcing an AI agent to guess how your framework works, the framework can provide the context the agent needs to work correctly. 🤯 Then you can bring the AI stack you want: 🤖 ChatGPT / AI Agents 🧠 Your preferred LLM 🔧 Tool Calling 🔌 MCP servers ⚙️ Custom agent frameworks 📡 External APIs 🗄️ Databases 🚀 Automation workflows https://lnkd.in/ehGnnTHu

We didn’t want to guess how much Claude usage was left. So we went looking at what Claude’s web app was already doing. That led us down an interesting engineering rabbit hole: Claude’s browser session receives usage and rate-limit information from an internal endpoint — including utilization and reset timestamps. The problem? A Chrome extension can’t simply intercept those authenticated requests from its content script. So we broke the whole flow down: → How we discovered the internal usage endpoint → Why the browser session can access it without an API key → Why a normal content script can’t intercept the request → How page-context script injection solves that limitation → How we capture and parse the response → How the data gets converted into usable rate-limit information → And the MV3 configuration required to make the injection work We documented the implementation, including the important things that DIDN’T work and why. This is the kind of engineering behind TokenPulse — not just building another dashboard, but figuring out how the tools developers already use actually work under the hood. Read the full breakdown on DEV.to: https://lnkd.in/dBmrjvUM If you're building Chrome extensions, developer tools, or anything around AI usage tracking, this one is worth a read. #AI #Claude #ChromeExtensions #JavaScript #WebDevelopment #DeveloperTools #AIEngineering #BuildInPublic #TokenPulse

New npm package. I've been playing around with AI tools for building websites lately, and one thing I noticed is that creating the website is becoming the easy part. You can ask AI to build you a pretty impressive frontend in a few minutes. But then you actually have to ship it. And that's where things can get messy. The site might still have localhost URLs, missing SEO tags, missing environment variables, accessibility issues, huge images, console logs, security issues, or even a production build that doesn't work. So I decided to build something for that last step. I just published an npm package: :𝗦𝗵𝗶𝗽𝗜𝘁 🚀 It's a CLI that checks a frontend project before you put it live and tells you what still needs attention. You can try it with: npx shipit-frontend-audit audit . The idea is pretty simple: AI helps you build the website. ShipIt helps you make sure it's ready to ship. It's still early and there's definitely a lot I want to improve, so if you try it, I'd really appreciate some feedback. If you find a check that's missing, a false positive, or just have an idea for something that would make it more useful, feel free to open an issue or reach out. 📦 npm: https://lnkd.in/gHjKQjJQ Would love to hear what you think. #OpenSource #WebDevelopment #Frontend #TypeScript #JavaScript #AI #DeveloperTools #npm https://lnkd.in/gHjKQjJQ

🚀 Excited to share my latest project: Website Explorer v2! An AI-powered Chrome Extension that analyzes any website in real-time and generates professional quality reports — think Lighthouse meets BrowserStack, right in your browser. 🔍 What it does: ⚡ Performance Analysis — Page load time, DOM content loaded, First Paint, FCP, transfer size & more 🔒 Security Analysis — HTTPS detection, mixed content, insecure forms, external scripts & password field detection ♿ Accessibility Analysis — WCAG-compliant checks for alt text, accessible names, input labels, heading order & more 🌐 Network Analysis — Total requests, JS/CSS/image/font breakdown, third-party requests & slow resources 🤖 AI Recommendation Engine — Priority-based fixes with root cause analysis and expected performance gains 📊 Dashboard gives you an overall website score plus individual scores for performance, security, accessibility & network. 📄 Export Reports in HTML and PDF formats — enterprise-style reports ready to share with your team. 🛠 Tech Stack: React • TypeScript • Vite • Chrome Extension Manifest V3 • jsPDF 🔗 Check it out on GitHub: https://lnkd.in/gyqdBDFr Contributions are welcome! Fork it, build on it, and let's make web quality analysis accessible to everyone. 💻✨ #WebDevelopment #ChromeExtension #OpenSource #React #TypeScript #WebPerformance #Accessibility #Security #AI #DeveloperTools #GitHub

I built a Chrome extension that reads the internet with me and it taught me way more than I expected. Meet JigyasaAI (jigyasa = curiosity, in Sanskrit) a research assistant that lives in your browser's side panel. Select any text on a page, and it'll summarize it, suggest related topics to dig into, or answer a question you type in. It also lets you save notes as you go and export them whenever you need them. The idea came from a habit I kept falling into: opening a dozen tabs while researching something, losing track of what I actually learned, and closing them all without ever writing a summary. I wanted something that sat right next to whatever I was reading and did the thinking-alongside-me part. What it's built with: ->A Chrome extension (Manifest V3) for the side panel UI ->A Spring Boot backend that talks to Google's Gemini API ->Chrome's storage API to save and manage notes locally A few things I learned building this: → API integrations look simple in a tutorial and get real the moment you build one yourself. Structuring request bodies, parsing nested JSON responses safely, handling failures without the whole thing breaking none of that shows up until you're the one wiring frontend, backend, and a third-party API together end to end. → Manifest V3's side panel API is a nice way to build extension UIs, but getting text selection to work reliably across both the webpage and the extension's own panel took more edge-case handling than I expected. It's still a work in progress deploying the backend so it doesn't need to run locally is next on my list. But it's already made my own research sessions noticeably less chaotic. Code's on GitHub if you want to look under the hood or fork it: https://lnkd.in/dnJTnEcE Would love to hear how others are handling their own "too many tabs" problem always curious what setups people have landed on.

Most developer tools start with an API. This one started with a question: “What is Claude’s web app already telling the browser about usage?” We dug into the browser network flow, found the internal usage endpoint, and then had to solve a second problem — how to actually access that response from a Chrome extension under Manifest V3. The interesting part wasn't just finding the endpoint. It was understanding the browser execution model, figuring out why the obvious approaches didn't work, and then building the right bridge between the page context and the extension. We wrote up the entire process, including the dead ends. If you're interested in Chrome extensions, reverse engineering web applications, or building better tooling around AI usage, take a look. 👇 Full breakdown: https://lnkd.in/dxifh6Wf Built as part of TokenPulse.

Make E-E-A-T actionable with Claude Code, this @sengineland guide shows marketers how to build a lightweight audit bot, fetch pages with a headless browser, and export a scored report, but remember E-E-A-T is not a ranking factor: searchengineland Will you build one? https://cstu.io/490b9a #google

AI agents shouldn't rely on visual DOM actuation and screenshot guesswork to interact with your site. WebMCP inverts the paradigm: your page explicitly declares what it can do via document.modelContext. But before you ship it, here’s what every engineer needs to know: 1️⃣ WebMCP ≠ MCP: Server-side MCP is persistent; WebMCP is ephemeral and tab-bound. 2️⃣ Chrome 150 Shift: navigator.modelContext is officially deprecated—use document.modelContext. 3️⃣ Security Diamond: Tool schemas don’t stop indirect prompt injection. Always enforce authorization at the last hop. 4️⃣ Two Paths: Imperative JS for app state vs. Declarative HTML <form toolname="..."> for markup-heavy sites. We put together an in-depth architectural guide covering the full spec, live Console snippets, and an edge-case testing matrix: 🔗 https://lnkd.in/eJtHb6f6 #AgenticWeb #WebDev #AIagents #JavaScript #WebStandards

🗓️ Post 43 | 22/08/2026 📊 Performance Monitoring – You Can't Improve What You Don't Measure Optimizing a website once isn't enough. As new features, dependencies, and code are added, performance can slowly get worse. That's why performance monitoring matters. 🔍 What Should We Monitor? ⚡ LCP – How quickly the main content appears 🖱️ INP – How responsive the page is to user interactions 📐 CLS – How stable the layout is 🌐 TTFB – How quickly the server starts responding 📦 Bundle Size – How much JavaScript users download 🐌 API Response Time – How long backend requests take 🛠️ Useful Tools 🔹 Chrome DevTools – Debug performance locally 🔹 Lighthouse – Analyze page performance 🔹 PageSpeed Insights – Check real-world performance data 🔹 Web Vitals – Monitor Core Web Vitals 🔹 Sentry – Track frontend errors and performance issues 👥 Lab Data vs Real Users A page can perform well on your laptop but poorly for users on: 📱 Low-end devices 📶 Slow networks 🌍 Different locations That's why Real User Monitoring (RUM) is valuable. It shows how your application actually performs for real users. 🔄 The Performance Cycle Measure → Identify → Optimize → Deploy → Monitor → Repeat Don't optimize based on assumptions. Find the bottleneck, fix it, and measure the result again. 💡 My Takeaway Performance isn't a one-time optimization. It's an ongoing process. A fast application today can become a slow application tomorrow if performance isn't monitored continuously. 💬 Question: What do you use to monitor frontend performance—Lighthouse, DevTools, PageSpeed Insights, Sentry, or something else? #FrontendPerformance #WebPerformance #ReactJS #CoreWebVitals #PerformanceMonitoring #JavaScript #FrontendDeveloper #WebDevelopment #SoftwareEngineering #LearningInPublic

Most frontend bugs that reach production aren't React bugs. They're browser bugs hiding underneath the application. Memory that never gets released. Requests that keep running after a component unmounts. Deep clones that silently lose data. Feeds repainting DOM nodes that don't need to be there. These problems are easy to miss in code review. They become very expensive when real users hit them at scale. I just published a deep dive into 6 underused Browser APIs and DevTools techniques that help catch and fix these problems: 🔹 Chrome DevTools 3-snapshot technique for finding memory leaks 🔹 AbortSignal.any() for combining timeout, unmount, and manual cancellation 🔹 structuredClone() vs JSON serialization for safely cloning complex data 🔹 CSS :has() for styling parents based on their children 🔹 content-visibility: auto for skipping unnecessary rendering work 🔹 requestIdleCallback for scheduling non-urgent work, with a Safari fallback The interesting part? These aren't just production techniques. They're also excellent frontend interview questions because they reveal whether someone actually understands how the browser works, beyond React APIs. I included code examples and diagrams for each one. 👉 Read the full breakdown: https://lnkd.in/dQNd47JM Which of these are you already using in production?