2025년 10월 20일의 Show HN

I got tired of playwright-mcp eating through Claude's 200K token limit, so I built this using the new Claude Skills system. Built it with Claude Code itself.

Instead of sending accessibility tree snapshots on every action, Claude just writes Playwright code and runs it. You get back screenshots and console output. That's it.

314 lines of instructions vs a persistent MCP server. Full API docs only load if Claude needs them.

Same browser automation, way less overhead. Works as a Claude Code plugin or manual install.

Token limit issue: https://github.com/microsoft/playwright-mcp/issues/889

Claude Skills docs: https://docs.claude.com/en/docs/claude-code/skills

Personally, I think the JJ VCS (https://github.com/jj-vcs/jj) hit a point some time in this past year where I find it hard to find a great reason to continue using `git`. Over the years I've cobbled together aliases and bash functions to try to improve my `git` workflow, but after using `jj`, which works with ~any git repo and integrates great with Github repos, all of the workflow issues I ran into with git are not only solved, but improved in ways I couldn't manage with simple scripts.

One example is the `op log`, which lets you go to any point in your repo's time and provides simple `undo` and `redo` commands when you want to back out of a merge, didn't mean to rebase, etc.

Because I have a pretty strong conviction that JJ is at this point a cleaner and more powerful version of `git`, my hopes are that it continues to grow. With that, it seemed a proper full-featured GUI was missing for the VCS. There's some plugins that add some integration into VS Code, and there's one in the works to get Intellij support working, but many of the constructs JJ provides in my opinion necessitate a grounds-up build of a GUI around how JJ works.

Right now, Judo for JJ is an MVP in an open beta. I did my best to support all of the core functionality one would need, though there's many nice-to-haves that I am going to add, like native merge support, native splitting, etc. Most of this will be based on feedback from the Beta.

I'm really grateful for the great community JJ has built, alongside the HN community itself in the countless VCS-based posts I've read over the years, and am hoping for lots of input here during Beta under real usage - the goal is to be a full-featured desktop GUI for the VCS, similar to many of the great products that are out there for git.

Hey HN,

For years, my local development setup has been a fragile mess of tools that never quite played nicely together. On my mac, it was a constant battle with Homebrew services starting (or not starting) on boot, conflicting PHP and Node versions managed by `asdf` or `nvm`, and a collection of `docker-compose.yml` files that I'd copy-paste and tweak for every single project. The cognitive load was just too high.

Setting up SSL was another chore involving `mkcert`. Sharing a quick demo with a colleague meant firing up ngrok. And if I wanted to run two projects that needed different versions of PostgreSQL? Good luck. I’d have to stop one service to start another.

I missed the simplicity of the MAMP/XAMPP era, but I needed something that could handle the diverse stack of a modern developer – not just PHP and MySQL, but Python, Go, Rust, Node.js, and various databases.

That’s why I (along with my small team) built ServBay. It's our attempt to bring back simplicity and speed to local development without sacrificing power. It's a native app for macOS and Windows, not a wrapper around Docker or VMs.

Here's what it does:

One-Click Stacks: You can install and run multiple, isolated versions of languages like Python, Node.js, Go, Java, Rust, Ruby, and .NET. No more path conflicts or environment variable hell.

Databases, Plural: This was a huge one for me. You can run multiple instances of MySQL, MariaDB, PostgreSQL, Redis, and MongoDB simultaneously. Project A can use Postgres 14 while Project B uses Postgres 16, both running at the same time on different ports.

Automatic SSL: Any host you create gets a valid SSL certificate out of the box. No more browser privacy warnings for `.test` or `.localhost` domains.

Built-in Tunneling: If you need to demo a feature or test a webhook, there's a one-click button to expose your local site to the internet via a secure tunnel.

One-Click Local AI: This is something we're really excited about. We've added a feature to easily download and run models like Llama 3 or Stable Diffusion locally through a simple UI, so you can experiment without worrying about API keys or costs.

Everything Else: It also handles one-click backups, has a clean, non-intrusive UI, and is designed to be as lightweight as possible.

I know what many of you are thinking: "Why not just use Docker?"

And that's a fair question. We use Docker for production and complex, multi-service architectures. But for quickly spinning up a single-service app, testing a new framework, or just general day-to-day development, the overhead of `Dockerfile`s, `docker-compose.yml`, slow file sync on macOS, and resource consumption often feels like overkill. ServBay is for those moments where you just want to get to the code.

The project is still young, and we have a long roadmap ahead. I'm here all day to answer any questions, listen to your (brutally honest) feedback, and hear about what your own development workflows look like.

You can check it out here: https://www.servbay.com

Thanks for reading.

I made it by 120% viba coding. enjoy! free and no ads.

Hey folks,

Here's a quick tool for anyone who wants a way to simplify error messages with AI without needing to switch to a fully agentic terminal solution. Simply add hank before compiling/running your program to get a clear, readable explanation of any errors that occur.

You can think of this as just another system utility like grep, ls or echo that is at your fingertips for debugging a program. It uses local models as well so your code outputs don't go into online LLM services.

Excited to see what gets thrown back, hope it helps someone. Feel free to add onto it as its pretty raw at the moment.

Hello, I made this site to combat misinformation on the internet by allowing users to prove that their claim is valid by linking multiple sources and combining them in a single link

It's very early stage so I would love feedback on: - What types of claims would be most useful to you? - How can I make verification/sourcing more robust? - Any features that would make this actually useful vs just interesting? Thanks in advance, feel free to roast :)

With the advance of AI, everyone is building and creating solutions. It is actually amazing to see people in Africa engage this creative field and produce products that could help their ecosystem.

So I built a platform that will soon be the biggest directory of tech products made by people in Africa to solve African Problems.

I am taking this path because I understand we have very different problems and different cultures and things work differently especially in Africa.

What do you guys think? I want your feedback on everything.

I just built Restring — a fast, modern toolbox for everyday dev tasks like formatting JSON, decoding JWTs, and converting strings.

I know there are plenty of similar tools out there, but I wanted something that felt instant and smart.

- Fast: Built with SvelteKit and plain HTML/CSS, with minimal dependencies and no UI bloat. The whole site is under 300 KB zipped and feels lightning quick. - Smart: It tries to detect what you paste (like JSON, JWT, or Base64) and routes you to the right tool automatically.

Currently supports: Base64, JSON, JWT, URL, Color, and DateTime.

I’ve used React, Vue, and Flutter before, but building this with SvelteKit was a joy — intuitive, minimal, and just works.

Would love feedback, especially on the auto-detection logic and ideas for other tools to add.

I've been interested in real-time Human-AI interaction for a while. This project is a prototype closed-loop drawing system, like "visual autocomplete" for drawings. The idea is that the user just draws along with the AI, without disrupting the flow through manual text prompting.

It works by AI continually observing and responding to live drawing on a canvas. A vision model (using Ollama) interprets what it sees, and that description drives real-time image generation (StreamDiffusion).

For real-time performance, this project is built in C++ and Python, leveraging the GPU for Spout-based texture sharing with minimal overhead.

Reusable components include: - StreamDiffusionSpoutServer: lightweight Python server for real-time image generation with StreamDiffusion. Designed for interfacing with any Spout-compatible software and uses OSC for instructions. - OllamaClient: minimal C++ library for interfacing with Ollama vision language models. Includes implementations for openFrameworks and Cinder.

The "visual autocomplete" concept has been explored in recent papers (e.g., arxiv.org/abs/2508.19254, arxiv.org/abs/2411.17673).

Hopefully, these open source components can help accelerate others experimenting and advancing this direction!

Whassup?,

A couple years ago, I started a project for easily authoring GUIs with Ruby. The project is named Hokusai. It features the ability to compose reactive UI components with events and props, and uses a unique-ish template language.

More information on Hokusai can be found here: https://hokusai.skinnyjames.net/

Since then I've worked on Hokusai Native (https://github.com/skinnyjames/hokusai-native-builder/), which compiles a GraalVM native image / TruffleRuby version of Hokusai that can run / interpret these lil' gui apps. It's quite bloated though, as it has to ship all of truffle ruby + native image and supporting libs.

Recently, I applied for a grant to develop a more portable version of this library using MRuby, and got pretty far while waiting for the results. It is named Hokusai Pocket and I consider it to be the final form/approach of this project.

I wrote a builder in crystal-lang that embeds the entire Hokusai ruby code as MRuby bytecode, as well as the supporting C code. It can scaffold new projects by building tree-sitter/mruby/raylib, and outputs a binary from a source ruby file.

It produce pretty small binaries (~3mb for MacOS) and uses raylib as the rendering engine.

For an gif and example of a Hokusai Pocket demo please direct your mouse clicks to this gist: https://gist.github.com/skinnyjames/b510185c6bd83fd4e1a41324...

I'd love to hear how this project plays for people. Still working on building for different targets, but android and web should be possible. The project is still undergoing active development, but any help is appreciated. The license is MIT.

There also is a discord channel if you want to get help / chat / collaborate: https://discord.gg/SexXSEw8Hh

       _    (^)
      (_\   |_|
       \_\  |_|
       _\_\,/_|
      (`\(_|`\|
     (`\,)  \ \
      \,)   | | 
        \__(__|

I built AskDesk because I wanted a simple way to talk to my computer without all the setup. It’s kind of like Raycast for Windows — you can type or speak commands like “clear temp files,” “open Spotify,” or “remind me to call my wife in 10 minutes.”

It also supports custom shortcuts, clipboard actions, and AI-powered commands. The AI part helps with things like searching, summarizing, or running smarter actions, but the core shortcuts are free forever.

Available now on the Microsoft Store: https://apps.microsoft.com/store/detail/9N8FPGKNWLFQ

I'm a developer (not a 3D artist) who's been frustrated with current AI text-to-3D tools — most produce messy, monolithic meshes that are unusable without hours of cleanup.

So I built NativeBlend, a side project aimed at generating editable 3D assets that actually fit into a real workflow.

Key features:

- Semantic Part Segmentation: Outputs separate, meaningful components (e.g., wheels, doors), not just a single mesh blob.

- Native Blender Output: Generates clean, structured .blend files with proper hierarchies, editable PBR materials, and decent UVs — no FBX/GLB cleanup required.

The goal is to give devs a usable starting point for game assets without the usual AI slop. I have a working demo and would love feedback: Does this solve a real need, or am I just scratching my own itch?

Thanks for taking a look!

Hi HN! I'm Ramesh, a 20-year-old developer from India.

I spent 8 months building VebGen – an autonomous AI development agent for Django projects. Built this at my cousin's house (limited internet at home), no degree, no team, $0 funding. The entire 500KB codebase was developed using free-tier models.

The Story: I wanted an AI agent that actually understands Django projects without burning through API tokens. Cursor and Copilot are great for line-level coding, but I wanted something that could build full features autonomously while staying within free-tier limits.

What VebGen Does: Think of it as having a senior developer + QA engineer working 24/7 on your Django project. You describe what you want ("build a blog with comments"), and it: • Plans the architecture (adaptive based on complexity) • Writes the code (models, views, URLs, tests) • Reviews for security (OWASP Top 10, N+1 queries) • Fixes bugs autonomously (70% success rate) • Never loses progress (auto-save with rollback)

How It Compares: Cursor/Copilot → Assisted coding (you type, they help) → Great for productivity VebGen → Autonomous development (you describe, it builds) → Different scope

Cursor → Sends code to LLM every analysis ($$$) → VebGen: AST parsing locally (free) Copilot → Auto-completion tool → VebGen: Full feature implementation Devin → $500/month, waitlist, closed → VebGen: Open source, runs locally, $0

Where VebGen shines: • Works on free-tier APIs (Cursor/Copilot require paid tokens) • Understands Django deeply (95+ constructs: models, views, serializers, signals, admin, Celery, Channels, etc.) • Self-healing (70% bug fix rate, tries 3 approaches) • Security-first (built-in OWASP Top 10 checks, N+1 detection) • State persistence (5 rolling backups, never lose progress)

Where Cursor/Copilot win: • Better UX/polish • Smoother IDE integration • Larger ecosystem

Key Innovation - Zero-Token AST Parsing: Instead of sending your entire codebase to an LLM every time (expensive!), VebGen parses Django code locally using Python's AST module. It understands 95+ Django constructs without consuming any API tokens.

Example: You have 50 files, ask "add user authentication". VebGen parses the AST locally (zero tokens!), identifies the 5 relevant files, then only sends those to the LLM. This makes it work beautifully on free-tier Gemini/OpenRouter.

Technical Highlights: Dual-agent system (TARS plans, CASE executes) Multi-tier patching (tries 3 methods before giving up) Military-grade sandbox (2,700 lines of security code) 5 rolling backups (crash-safe with SHA-256 verification) 319 tests, 99.7% passing Works with 120+ models across 5 providers

Built for Developers: • Desktop app (Python + CustomTkinter) • Detailed architecture docs (15 markdown files) • Full test coverage with examples • Open source, MIT license

I'd love to hear your thoughts! Especially feedback on: - The AST parsing approach (is this the right abstraction?) - Security architecture (did I miss anything?) - What other frameworks should I support next? (Flask, FastAPI, React?)

GitHub: https://github.com/vebgenofficial/vebgen

Happy to answer any technical questions about how it works under the hood!

I built a typescript app that will take a directory of mp3 files, rip the metadata and cover art, and turn them into a podcast feed. I had been self-hosting a podcast feed for a couple friends and wanted to build something better than I had found previously, at least for my specific use case.

I wouldn't be happy turning this in at work = it's not perfect, definitely not optimized, and docs need work. I'm sure it breaks a lot of rules for clean code, good abstractions, and proper nodejs usage, but it's my first time using ts/js for backend and I haven't always had the time for personal coding projects like I've wanted to, so I'm just glad it's working.

Just swapped out the docker image on my homelab and was excited to start seeing per-episode cover art show up in my feed.

Systems engineers model billion-dollar spacecraft, life-saving medical devices, and autonomous vehicles in tools that can't even do a proper diff/merge/version control even with large expensive infrastructure.

I built Sylang to address that.

What is Sylang?

A text-based language for modeling complex systems. Write declarative code, get visual diagrams, traceability matrices, FMEA analyses, and compliance reports automatically. Works with Git, VSCode, and AI code assistants.

Example:

  def requirement BrakeActivation
    description "System shall activate brakes within 100ms"
    safetylevel ASIL-D
    testedby ref testcase EmergencyBrakeTest
    derivedfrom ref safetygoal PreventCollision
    allocatedto ref block BrakeController

This generates:

- Architecture diagrams (decomposition, internal block diagrams) - Traceability matrix (requirement ↔ test ↔ block ↔ safety goal) - Coverage analysis (which requirements lack tests?) - Compliance reports (functional safety, ASPICE, etc.)

Why text-based modeling works:

Your AI code assistant (Cursor, GitHub Copilot, Claude, Gemini) can: - Generate requirements from safety goals - Create test cases from requirements - Draft FMEA analyses from architecture - Refactor across files with semantic understanding - Suggest missing relationships

Git workflows that actually work:

  git diff requirements.req        # See what changed
  git merge feature/new-sensors    # Merge architecture branches
  git blame safety-goals.sgl       # Who defined this safety goal?

No XMI. No database exports. No PowerPoint. Just readable text that generates everything you need.

What you get:

23 file types covering the full engineering lifecycle: - Product lines & variants (.ple, .fml, .vml) - Architecture (.blk, .fun, .ifc) - Requirements & tests (.req, .tst) - Behavioral models (.ucd, .seq, .smd) - Safety analysis (.haz, .sgl, .sam, .flr, .fta) - Dashboards & specs (.dash, .spec) - Automation (.agt, .spr)

All auto-generating visual diagrams: feature models, decomposition diagrams, sequence diagrams, state machines, traceability matrices.

Current state:

- Language stable (v0.9.27) - VSCode extension available (search "Sylang" in Extensions) - Works with Cursor, GitHub Copilot, Claude, Gemini code assistants - Diagram rendering, traceability, coverage analysis working - Solo dev, part-time, building in public

Download at:

https://marketplace.visualstudio.com/items?itemName=balaji-e...

Website: https://sylang.dev

GitHub: https://github.com/balaji-embedcentrum/sylang

Feedback welcome—especially from engineers who've wished their modeling tools worked more like their code editors.

Copilot AI Agent is a set of free tools that use artificial intelligence to support and assist developers in writing, understanding, and analyzing programming code.