标签：#tooling

The document hub, our vision of DocuShark . We want to make collaboration simple again. There are too many amazing tools, too many surfaces to get lost in. Bring them together - and you've got a near-endless wealth of knowledge for anyone with access. The editor is out, and loaded with features, only getting more powerful. Our editor offers: high-speed, realtime collaborative editing on documents in your Cloud Workspace, documents that can write, draw, and store files at the same time, never lose access when your network goes out - offline copies let you use every feature anywhere, and agent endpoints (MCP) for all your agentic needs. The page and canvas are one, with generous file storage, allowing you to design whitepaper-level PDFs in hours, not weeks, with every file, reference, and diagram within that document, all while offline with changes saving when you're back online. It's a mini Google Drive in each document, with offline storage so you can edit anywhere, anytime with changes syncing across your team. The Integrations Story - Combine, don't Compete DocuShark isn't here to compete, it's here to integrate, and keep complex ideas lean and organized across platforms. As we release our integrations, knowledge drift shrinks, leaving you with richer context while you keep working with your favorite apps - or don't, we have rich editor tools as well. An Agent Powerhouse - Keep your Context Close DocuShark is built for agents from the ground up. Citations keep your agent's research properly attributed. Fields eliminate drift and block duplication before it starts. Anchored edits make changes surgical, not sweeping. More is in the works, and the roadmap is moving fast. Try DocuShark - The Editor's Free and Fast You can either launch straight into the editor , or get a cloud workspace and start collaborating today!

I 've been using Cursor on non-trivial repos and kept hitting the same issue: the agent finds a file but misses routes, shared modules, and tests that should run after a change. I built FlowIndex — a local CLI + MCP server that scans a repo and builds a behavior graph in SQLite (entrypoints, imports/calls, tests, git co-change). No embeddings, no SaaS, no LLM calls in the index itself. Setup: pip install "flowindex[mcp]" In your project: flowindex init flowindex scan Add to ~/.cursor/mcp.json (use your repo' s absolute path for cwd ) : { "mcpServers" : { "flowindex" : { "command" : "flowindex" , "args" : [ "mcp" ] , "cwd" : "/absolute/path/to/your/repo" } } } 4. Restart Cursor — you get tools like get_change_impact, suggest_tests, make_context_pack, explain_entrypoint, get_repo_overview. Example workflow: before editing payments/ledger code, ask the agent to use make_context_pack or get_change_impact on that file — it pulls from the local graph, not a generic file search. Honest limits: static analysis + git heuristics only. Call paths resolve via imports but aren 't compiler-grade. TS/JS is heuristic. Documented in the README. MIT · pip install flowindex · https://github.com/adu3110/flowIndex Curious if others use MCP for repo context and what tools you wish existed. Happy to fix setup issues if anyone tries it.

AI can generate unit tests in seconds. But how do you know whether those tests are actually useful? Most teams still rely on code coverage and pass rates to evaluate their test suites. The problem is that a test can pass, increase coverage, and still provide little or no additional confidence. We've been seeing examples where AI-generated tests: Duplicate existing coverage Depend on system time or GUID generation Access files, network resources, or environment variables Use ineffective or unnecessary mocking Add maintenance cost without improving quality Today we launched Typemock Test Review, a tool that analyzes tests during execution and identifies duplicate, fragile, ineffective, and high-maintenance tests. Instead of looking only at source code, it combines runtime behavior, code coverage, dependency analysis, assertions, and mocking patterns to determine whether a test is actually contributing value. Some of the issues it can detect: Duplicate tests Hidden external dependencies Flaky test risks Unused or stale fakes Ineffective mocking Tests that increase maintenance without increasing confidence I'm curious how other teams are dealing with the explosion of AI-generated tests. Are you reviewing AI-generated tests differently from manually written tests? Have you found good ways to measure test quality beyond coverage and pass/fail metrics?

TL;DR: What gadgets, tools, furniture and whatnot do I need for an ideal desk setup for a...

According to product onboarding and SaaS activation research compiled by Appcues and industry...

MCP is useful, but most of the time you do not actually need it. It gives an agent a clean way to discover tools, call APIs, and work with external systems. In practice, a skill file can describe the same usage path without dragging the whole MCP surface into context. But MCP is not free; rather than MCP itself, the real issue is the habit of loading a big MCP surface into every session, no matter what the session is actually about. Once a Claude Code or Codex run pulls in a bunch of servers, the model sees those tool definitions right away, even if the job is just writing docs or fixing a small bug. That is where the waste starts. The hidden cost of always-on MCP Every MCP server brings metadata with it: tool names, descriptions, argument schemas, nested parameters, enums, examples, and sometimes prompts or resources. While useful, this is still context. If you connect a handful of lightweight tools, the overhead is annoying but manageable. If you connect a real stack of services, the cost compounds fast. In practice, you end up paying for: tool discovery before the task starts schema text the model may never use repeated loading across unrelated sessions extra context pressure that pushes out the actual work That last point matters more than people think. Context acts as the active working set the model uses to reason. The more of it you burn on static tool catalogs, the less room you have for the user request, the repo state, prior reasoning, and the actual answer. Anthropic has already written about this problem directly in the context of MCP. Their engineering post on code execution with MCP calls out tool-definition bloat and shows how direct tool calls can consume a lot of context before the model even starts doing the real job. The tool list is not just setup noise; it is part of the session cost. Why skills are cheaper Skills take a different path. A skill file keeps the always-loaded portion tiny. Usually that means just the skill name and a short descript

Tools Full comparisons and context in my 2026 AI tech stack post . This is just what you need installed to follow the workflow below. Claude Code If you're new, start with the cheat sheet and Anthropic best practices . Security — set this up first: Claude Code Security Hooks — 7-layer prompt injection defence, read guards, canary files Lock down your .env and any git-secret files in .claude/settings.local.json before anything else MCP: Context7 — library/API docs on demand DeepWiki — open source repo documentation Skills: Matt Pocock's skill set — /grill-me , /handoff , /improve-codebase-architecture (covered in detail below) Understand Anything — interactive code knowledge graphs Ponytail — laziest-senior-dev heuristic, pairs well with /improve-codebase-architecture Agents: DocsExplorer — handles docs lookup in a subagent without polluting main context Hooks / proxies: rtk — token reduction proxy, single Rust binary UI: Claude HUD — status bar showing model, context size, active tools and agents Other tools JetBrains — for git, debugging and reviewing Claude's changes; Claude Code plugin Warp.dev — terminal; Warp Oz for hands-off tasks, Claude Code for hands-on Process As I've mentioned in previous posts, my workflow is typically very different from what you'll see in the hype and social media posts. I don't typically work on monorepo, single stack, single language projects. My clients are typically full-on microservices with multiple languages and stacks. And beyond that, I still prefer IDEs over fancy pluggable text-editors, which often means I can't keep all the projects single scoped. What this means is that current favourites like Air , Conductor , and Antigravity don't work for me. So I've been solving my own problems, and this process I'm sharing today allows me to employ multiple agents working mostly independently on different repos towards a singular goal. I treat my agents like I would juniors or contractors; trust but verify. I give them tasks, but I ha

AI Coding Agents Need a Control Layer AI coding agents are getting good enough that the problem is changing. A year ago, the question was mostly: Can this thing write useful code? Now, for a lot of builders, the better question is: How do I supervise this thing once it is actually doing work? That shift feels important. Claude Code, Cursor, Codex, and similar tools are not just autocomplete anymore. They can plan, edit files, run commands, review code, and work across larger chunks of a project. That is powerful. It also gets messy fast. The bottleneck is moving The hard part is no longer just picking the best coding agent. It is figuring out how to manage agent work once multiple tools or sessions are active. Questions start showing up: What is each agent doing right now? What changed? What still needs human review? Where did approval happen? Which agent owns which task? Did two agents touch the same part of the codebase? What should be paused, redirected, or stopped? What happened while I was focused somewhere else? That is not really a prompting problem. It is a control problem. The current workflow is mostly duct tape A lot of agent workflows seem to rely on some combination of: terminal tabs tmux sessions git branches git worktrees editor diffs notes issue trackers rules files memory vibes That works for a while. But once agents become more autonomous, or once a builder runs more than one agent at a time, the workflow starts to need a real operating layer around it. Not because the agents are bad. Because the agents are getting useful enough to need supervision. The missing layer The layer I keep thinking about has a few jobs. State What is running? What is paused? What needs attention? Ownership Which agent owns which task, branch, file, or objective? Review What changed, and what still needs a human to look at it? Approval Where should the human say yes before work continues? Intervention When should a builder pause, redirect, compare, or stop an agent? Memor

A working prompt library is the main event, not an appendix. The industry still treats prompts as some half-baked spitball left in a README, or, worse, a plaintext blob stapled to package.json and forgotten. That's a waste of compute and credibility. What powers reliable AI-assisted refactoring, onboarding, or even next-gen code IDEs is not the size of the model but the clarity and context supplied by the actual, shipped prompt set. OTF kits turn this lesson into a repeatable deliverable: every paid template includes 20+ production-tested prompts tied to the real file structure, component API, and product-specific conventions. This is not a suggestion; it's structural. The takeaway: a real prompt library is as important as your component library. Treat it like one. Start with the pain: why blank chat boxes don't scale The web is full of “integrations” that paste a blank chat input over your codebase and call it an “AI coding assistant.” The result: hallucinated function names, invented conventions, broken import paths. Here’s what happens in real life: Dev: "Add a social login button." AI (blank prompt): "Sure! Insert <SocialLoginButton> in your LoginScreen.js." Dev: (There’s no such component. There's not even a LoginScreen.js.) Short: A generic prompt with zero context simply can't know your conventions, files, or patterns. The agent will either fail, hallucinate, or pepper you with clarifying questions you have already answered in your product architecture. Takeaway: Prompting without context is coding without types — fragile guesses instead of structured outcomes. What a first-class prompt library enables When the prompt library ships with the codebase, it looks like this: Every prompt knows the folder structure (e.g., features/auth , screens/Settings/index.tsx ). Conventions are hard-coded: naming, import styles, design token usage. Endpoints and integration points (e.g., “update the Stripe webhook handler in api/webhooks/stripe.ts ”) are spelled out. The promp

Every time I started a new AI chat session, it read my entire codebase. 50 files. Thousands of tokens. On every single message. Whether I was asking about authentication, database schema, or a single UI component — the AI read everything. I'm 16 and building AI-powered products. Token costs add up fast. Context windows fill up. The AI loses track of older files. Responses slow down. So I built something to fix it. The Problem When you work with AI on large projects, you face a choice: Give the AI too much context → burns tokens, hits context limits, slower responses Give it too little → AI misses important files, makes wrong assumptions There's no middle ground — or at least there wasn't. Introducing FolioDux FolioDux is a lightweight, open-source file-mapping standard for AI-assisted development. The idea is simple: instead of giving your AI every file, you give it a compact index that tells it where everything is and what it does . The AI reads the index first, identifies the relevant files, and reads only those. One file. Two rules. Any AI. It works with Claude, ChatGPT, Gemini, Cursor, Copilot — any tool that accepts a system prompt. How It Works You add one file — FOLIODUX.md — to your project root. # FOLIODUX · TaskFlow · v1.0 · 2026-06-18 · 17 files STACK: React19+TypeScript+Vite · Express+SQLite · JWT --- ## TASKS auth/login/register → AuthView.tsx, authService.ts, server.ts create/edit task → TaskForm.tsx, taskService.ts, server.ts, types.ts list/filter tasks → TaskList.tsx, taskService.ts database → db.ts, server.ts --- ## INDEX App.tsx | fe | root: routing, auth state, layout wrapper AuthView.tsx | fe | login + register forms, error display taskService.ts | svc | CRUD tasks, local cache, optimistic updates server.ts | be | Express: all routes — auth, tasks, projects, user db.ts | be | SQLite setup, schema creation, migrations on boot types.ts | typ | Task, Project, User, Status(todo|in-progress|done) --- ## GROUPS Frontend: App.tsx · AuthView.tsx · TaskLi

YINI Specification RC 6 is now released The YINI configuration format has reached Specification Release Candidate 6 . YINI is a configuration format designed to feel familiar if you like INI-style files, but designed to bring more explicit structure, clarity, useful data types, and predictable parsing rules to real-world configuration needs.. The short version: @yini ^ App name = "Example" version = "1.0.0" debug = false ^^ Server host = "127.0.0.1" port = 8080 ^^ Features enabled = [ "auth", "logging", "metrics", ] YINI tries to sit somewhere between classic INI, JSON, TOML, and YAML: More structured than traditional INI. Less punctuation-heavy than JSON. Indentation-insensitive unlike YAML. Explicit about parsing rules and validation behavior. RC 6 is an important release because it tightens several parts of the language and moves the format closer to a stable 1.0 specification. What changed in RC 6? RC 6 includes a number of syntax and behavior updates. The main theme is the same as before: Make the format clear for humans, but deterministic for parsers. Here are some of the notable updates. Clearer section markers YINI uses section markers to define structure. ^ App name = "MyApp" ^^ Server host = "localhost" ^^^ TLS enabled = true The number of section markers defines the nesting level. This keeps hierarchy visible without relying on indentation. The primary section marker is: ^ YINI also supports alternative section markers, but ^ remains the recommended default for most files and examples. Strict and lenient mode behavior is more clearly defined YINI has two parsing modes: Lenient mode — practical, forgiving, and intended as the default. Strict mode — validation-focused and intended for stricter tooling, CI checks, and production-sensitive configuration. A file can declare its intended mode: @yini strict or: @yini lenient RC 6 clarifies how these declarations should behave when the file is parsed in a different mode. The goal is to avoid silent surprises. If

AI Observability for Lovable Apps: Monitor Prompts, Traces, and Evaluations with Currai Building AI applications has never been easier. Tools like Lovable allow developers and founders to create AI-powered products in minutes. Whether you're building a chatbot, AI assistant, recommendation engine, AI agent, or prediction app, generating the application is often the easy part. The real challenge starts after launch. How do you know what prompts are being sent to the model? How do you debug unexpected AI responses? How do you compare prompt variations and determine which performs better? How do you evaluate output quality over time? How do you track token usage and costs? This is exactly why we built Currai . What is Currai? Currai is an AI observability platform that helps teams understand, test, and improve AI applications in production. It provides: Prompt tracing AI request monitoring Session tracking Prompt versioning A/B testing LLM evaluations Cost and token analytics OpenTelemetry support Instead of guessing why your AI application produced a particular response, Currai lets you inspect the entire execution flow. The Problem With AI Applications Traditional monitoring tools were built for APIs, databases, and backend services. AI applications introduce a completely different set of challenges: Prompt changes can significantly impact output quality Model updates can affect behavior Hallucinations are difficult to track User conversations are hard to debug Prompt experiments are often unmanaged Quality evaluation is usually manual When something goes wrong, application logs alone don't provide enough visibility. You need observability designed specifically for AI systems. Trace Every AI Request Currai captures every prompt, model response, latency metric, token usage, and cost. You can inspect: System prompts User prompts Model outputs Execution traces Tool calls Metadata This makes debugging AI applications dramatically easier. Run Prompt A/B Tests Prompt engin

Ihre OpenAPI-Datei ist die Quelle der Wahrheit für Ihre API: Pfade, Parameter, Request-Bodies, Responses und Schemas. Für Entwickler im Alltag ist rohes YAML oder JSON aber selten das beste Lesematerial. Backend-Teams brauchen eine schnelle Endpunkt-Referenz im Repository, Frontend-Teams wollen Request- und Response-Felder im Pull Request prüfen, und technische Redakteure möchten Inhalte in Wiki- oder Docs-Systeme übernehmen, ohne Schemas abzutippen. Testen Sie Apidog noch heute Markdown ist dafür das praktischste Zielformat. Es funktioniert in GitHub, Confluence, Notion, Docusaurus, MkDocs, Hugo und jedem Texteditor. Die Aufgabe lautet also: Aus einer vorhandenen openapi.yaml automatisch sauberes Markdown erzeugen. Manuell ist das zu langsam und driftet beim nächsten API-Change auseinander. Automatisch generiertes Markdown bleibt dagegen Teil Ihres Release-Prozesses. Warum Markdown aus OpenAPI generieren? Ein OpenAPI-Dokument ist primär für Maschinen gedacht. Tools parsen es, um Clients zu generieren, Contract-Tests auszuführen, Requests zu validieren oder interaktive Dokumentation zu rendern. Diese Maschinenlesbarkeit sollten Sie beibehalten. Wenn Sie zuerst die Qualität Ihrer Spezifikation prüfen möchten, hilft der Leitfaden zu OpenAPI-Validierungstools . Markdown löst ein anderes Problem: Es macht die API dort lesbar, wo kein OpenAPI-Renderer läuft. Typische Einsatzfälle: README.md oder /docs im Repository Pull-Request-Beschreibungen für neue oder geänderte Endpunkte Confluence- oder Notion-Seiten für Team-Reviews Statische Dokumentationsseiten mit Docusaurus, MkDocs oder Hugo Offline- oder interne Referenzdateien für Support und QA Wichtig ist: Markdown sollte ein abgeleitetes Artefakt sein. Die OpenAPI-Spezifikation bleibt kanonisch, Markdown wird bei Änderungen neu erzeugt. Methoden im Überblick Es gibt keinen offiziellen OpenAPI-Befehl für Markdown-Export. In der Praxis nutzen Teams entweder Konverter, ein eigenes Skript oder eine API-Plattform. Methode Am b

Pipeline & Prompts | Byte size guides on DevOps, Cloud and AI ** AI in the Stack #1** Byte size summary After reading this article, you'll have a framework for evaluating AI tools in platform engineering contexts — not by capability type, but by where in your workflow the tool actually changes the outcome. You'll understand why the tools that sound most compelling are still hype, where genuine productivity gains exist today, and what governance infrastructure you need in place before any AI component gets near production. This article is the foundation for the series; subsequent articles implement each touch point against real OpenShift infrastructure. The story I spent months selling IBM's AI and data science portfolio before I truly understood what I was selling. I knew the pitch. Predictive analytics. Optimization. Decision intelligence. I could walk a room through the business value without breaking a sweat. CPLEX for scheduling, Watson for insights — I had the slides, the talking points, the customer stories. Then I sat in on a data scientist demo. Not a sales demo. An actual working session — models being trained, outputs being interrogated, assumptions being challenged in real time. And somewhere in that room, watching someone do the thing I'd been describing from the outside, something clicked — and not in a good way. The models were impressive. The theory was solid. But I kept asking myself the same quiet question: where does this go next? Because most of what I saw never made it anywhere near production. It lived in notebooks. In slide decks. In proof-of-concept environments that were never ready to cross the line into something real. I'd been selling outcomes — optimised schedules, smarter decisions, reduced costs — without a clear path to how you'd actually get there. And underneath all of it, something else bothered me that nobody was talking about loudly enough: the data going into these models was often messy, unvalidated, and ungoverned. Bias wasn't

AI coding agents are becoming better at changing software. That is no longer the hardest problem. The harder problem is keeping the repository understandable after those changes land. Code changes quickly. Documentation often does not. Product intent lives in chat history. Architecture notes fall behind. Reviewers can inspect the implementation diff, but they often cannot see whether the product promise, engineering contract, and repository workflow are still aligned. Truthmark is built for that gap. It is a Git-native workflow layer for AI-assisted software development. It installs repository-local truth workflows so AI agents can keep canonical truth docs aligned with functional code changes, while humans still review normal Git diffs. Truthmark 2.2.0 takes a significant step forward: it separates product truth from engineering truth. That may sound like a documentation detail. It is not. It is a workflow boundary for AI coding agents. Why truth needs lanes Most documentation systems treat “docs” as one surface. That works until AI agents start using those docs as operational context. A product promise and an implementation detail are not the same kind of truth. A product doc should say what must be true, why it matters, who benefits, what boundary is being protected, and what success means. An engineering doc should say how the repository currently realizes that promise: the behavior, contract, architecture, workflow, operations, tests, and source-backed implementation facts. When those two kinds of truth collapse into one file, the result is usually weak in both directions. Product truth becomes a summary of implementation mechanics. Engineering truth becomes a detailed version of product rationale. Neither is ideal for humans. Neither is ideal for agents. Truthmark 2.2.0 introduces explicit product and engineering lanes so agents can reason about these surfaces separately. The core rule is simple: Product truth says what must be true and why. Engineering truth

As developers, we compare files constantly — reviewing pull requests, checking config changes, spotting bugs between versions. But not all diff tools are created equal. Some require installation, some upload your files to remote servers, and some just don't support the formats you need. Here's a rundown of the best free file diff tools available in 2026, so you can pick the right one for your workflow. 1. FileDiffs — Best for Privacy & Format Support If you work with sensitive files or just don't want your data sitting on someone else's server, FileDiffs is the tool you need. What makes it stand out: Supports 60+ file formats — PDF, Word, Excel, code files, JSON, XML, CSV and more Runs entirely in your browser — client-side processing means your files never leave your device 100% private — zero data transfer, zero uploads, zero risk No install, no signup, no hassle — just open and compare It's the go-to tool when you need to compare files quickly without worrying about privacy or compatibility. 2. Meld — Best Desktop Diff Tool Meld is a classic open-source visual diff and merge tool for Linux, Windows, and macOS. It's great for comparing files, directories, and version-controlled projects. Best for: Developers who prefer a desktop app and work heavily with Git. 3. Beyond Compare — Best for Power Users Beyond Compare is a feature-rich diff tool with support for files, folders, FTP, and cloud storage. It's not free (paid after trial) but worth mentioning for its depth of features. Best for: Teams that need advanced folder sync and merge capabilities. 4. Diffchecker — Quick Online Diffs Diffchecker is a simple web-based diff tool for text and code. It's quick and easy but uploads your content to their servers and has limited format support compared to FileDiffs. Best for: Quick one-off text comparisons where privacy isn't a concern. 5. KDiff3 — Best for Three-Way Merges KDiff3 is a free, open-source diff and merge tool that supports three-way comparison. It's a bit dat

Word scrambling is a deceptively simple mechanic. Rearrange the letters of a word, ask someone to restore the original — that's the entire game loop. But underneath that simplicity is a cognitive process that language researchers find genuinely interesting, and that developers building educational tools keep returning to. The Cognitive Mechanics of Unscrambling When a learner attempts to unscramble a word, they're engaging several parallel cognitive processes: pattern recognition (matching letter combinations to phonemes they know), memory retrieval (searching their lexical database), and hypothesis testing (trying a mental arrangement before committing). It's a lightweight version of the same cognitive work that makes retrieval practice so effective in spaced repetition systems. For language learners specifically, this is high-value low-stakes practice. The scrambled form gives enough context to confirm the answer upon success — no ambiguity like a multiple-choice distractor — while requiring genuine active recall. Implementation Considerations for Developers If you're building a word scramble feature into an educational app, a few things matter: Avoiding anagram collisions: "SILENT" → "LISTEN" is a classic example. Your scrambling algorithm needs to detect valid English words in the output and regenerate if it creates a different real word. A dictionary API lookup on the scrambled result handles this. Difficulty calibration: Longer words and words with repeated letters (like "BALLOON") are objectively harder to unscramble. A good difficulty curve starts with 4–5 letter words and increases length progressively. First/last letter anchoring: Keeping the first and last letters in position is a widely used technique to reduce cognitive load. It's psychologically effective — people anchor on word edges more than the interior. Using Existing Tools vs. Building Your Own For most educational content creators and teachers (non-developers), building their own tool isn't feas

I was working on a project and needed to convert some Markdown to HTML. Searched for it online, found a site, done. Next day I needed HTML back to Markdown. Searched again, different site. Then JSON to CSV. Then something else. Different site every time, half of them slow. At some point I just thought — why not build one site that handles all of this? So I did. That's QuickConvert . What It Is Just a collection of the conversions I kept searching for: JSON → CSV and back Markdown → HTML and back JSON → YAML XML → JSON CSV → JSON HTML → PDF Nothing fancy. No account needed. Everything runs directly in your browser — no data is sent anywhere, nothing is saved on a server. Why Astro I also wanted to try Astro for a while. I kept hearing it was great for content-heavy sites because of how little JavaScript it ships by default. A converter site felt like the perfect use case — mostly static pages with one interactive tool on each. Since Astro works with React components, it wasn't a big adjustment once I got the basics down. You write your page layout in .astro files and drop in React components where you need interactivity. Clicked pretty quickly. The result — 100 on Lighthouse across the board. The pages load instantly because there's barely anything to load. Hosting Deployed on Cloudflare Pages (now cloudflare workers). Free tier. The only thing this site costs me is the domain name. Try It quickconvert.dev Runs in your browser, no account, no data saved anywhere. I'm planning to keep adding more conversions — the everyday ones that developers reach for and end up Googling every single time. Maybe we can make something that becomes a tab that just stays open. Feedback welcome — especially if a conversion you need isn't there yet.

Here's a small thing that drove me up the wall using Claude Code on a real codebase. I have a pre-commit hook. It runs the linter and the type-checker. It exists precisely so that broken code doesn't reach a commit. And Claude — diligent, eager, trying to be helpful — would hit a failing check, decide the check was in the way of the goal , and quietly run: git commit --no-verify -m "fix: update handler" It wasn't malicious. From the agent's point of view, the task was "commit this change," the pre-commit hook was an obstacle, and --no-verify was the documented way around the obstacle. Perfectly logical. Also exactly the thing I never want to happen, because the entire point of the check is that it is not optional . I tried the obvious fix first: I put it in CLAUDE.md . Never use git commit --no-verify . Fix the failing check instead. This works about 80% of the time. Which is another way of saying it fails one commit in five. CLAUDE.md is context — a strong suggestion the model weighs against everything else in the conversation. Under enough pressure ("just get this committed"), a suggestion loses. An 80%-reliable guardrail on something irreversible isn't a guardrail. It's a coin flip with good odds. So I stopped trying to persuade the model and started intercepting the tool call instead. Hooks run before the action, not after the apology Claude Code has a hooks system. The one that matters here is PreToolUse : a script that runs before a tool call executes, receives the call as JSON on stdin, and decides whether it proceeds. Exit 0 and the call runs. Exit 2 and it's blocked — and whatever you wrote to stderr gets fed back to the model as the reason. That last part is the whole game. It's not "please don't." It's a wall, plus an explanation the model can act on. Here's the entire hook: #!/usr/bin/env node // Block `git commit/push --no-verify`. Exit 2 blocks the call. ' use strict ' ; let raw = '' ; process . stdin . on ( ' data ' , ( d ) => ( raw += d )); process .

Every week I open a new browser tab and search for something like "json formatter online" or "jwt decoder" or "regex tester". And every week I land on a site that: Shows me three ad banners before I can see the tool Requires me to create an account to "save" my work Is quietly uploading my payload to their server That last one bothers me most. Developers paste real things into these tools — JWT tokens with live user data, passwords they're about to deploy, private keys, internal API responses. Most people assume these tools are "just a webpage" and nothing is being sent anywhere. Often that's not true. So I built SnapTxt — a collection of 50+ developer utilities that run 100% client-side. No backend. No account. No tracking. Your data never leaves your browser. What's in it The toolkit covers the things I reach for most often: Data & text JSON formatter, validator, minifier, diff, tree explorer SQL formatter XML formatter YAML → JSON, CSV → JSON converters Base64 encode/decode, URL encoder, hash generator Auth & security JWT decoder & generator RSA key generator bcrypt generator x.509 certificate decoder Password generator Images Image compressor Image format converter Image to text (OCR via Tesseract.js) SVG to PNG, favicon generator, code-to-image Frontend / CSS Regex tester CSS gradient generator, box shadow generator Color converter Mermaid live editor HTML live editor, HTML to Markdown, HTML to JSX Cron expression builder And more — word counter, text diff, unix timestamp, lorem ipsum, QR code generator, markdown to PDF, and a collection of Australian and NZ business number validators. How it's built It's a Next.js app deployed as a fully static export to Firebase Hosting. There is no server. Every tool runs in the browser using: CodeMirror 6 for editor-style inputs Tesseract.js for OCR (runs a WASM binary in a web worker) Chrome's built-in Prompt API (Gemini Nano) for the AI explain features in JSON, SQL, and JWT tools — meaning even the AI inference is on-dev