Show HN for April 1, 2026

I kept deleting and redownloading Instagram because I couldn't stop watching Reels but needed the app for DMs. Tried screen time limits, just overrode them. So I built this.

Dull loads Instagram, YouTube, Facebook, and X and filters out short-form content with a mix of CSS and JS injection. MutationObserver handles anything that lazy-loads after the page renders, which is most of the annoying stuff since these platforms love to load content dynamically.

The ongoing work is maintaining the filters. Platforms change their DOM all the time, Instagram obfuscates class names, YouTube restructures how Shorts appear in the feed, etc. It's a cat-and-mouse thing that never really ends.

Also has grayscale mode, time limits, and usage tracking.

Happy to answer questions.

I built a real-time flight tracker that renders 10,000+ aircraft on an interactive 3D globe, entirely in the browser using Rust compiled to WebAssembly.

This project (Agents Observe) started as an exploration into building automation harnesses around claude code. I needed a way to see exactly what teams of agents were doing in realtime and to filter and search their output.

A few interesting learnings from building and using this:

- Claude code hooks are blocking - performance degrades rapidly if you have a lot of plugins that use hooks - Hooks provide a lot more useful info than OTEL data - Claude's jsonl files provide the full picture - Lifecycle management of MCP processes started by plugins is a bit kludgy at best

The biggest takeaway is how much of a difference it made in claude performance when I switched to background (fire and forget) hooks and removed all other plugins. It's easy to forget how many claude plugins I've installed and how they effect performance.

The Agents Observe plugin uses docker to start the API and dashboard service. This is a pattern I'd love to see used more often for security (think Axios hack) reasons. The tricky bit was handling process management across multiple claude instances - the solution was to have the server track active connections then auto shut itself down when not in use. Then the plugin spins it back up when a new session is started.

This tool has been incredibly useful for my own daily workflow. Enjoy!

Hi,

I built this because running multiple Claude Code agents across multiple IDE and terminal windows was getting messy. Like many, I went from working at one thing at the time, to multiple, and it was all changing quite fast.

I needed one place to see all my agents and worktrees, seamlessly switch between them, monitor their status and once their done, review their changes. I also wanted to quickly spin up new agents in isolated worktrees whenever an idea came to mind.

I've been building Baton from within Baton for a while now, which has been a pretty fun loop. Would love to hear what you think!

WordBattle is a daily 6-letter word guessing game with team leaderboards. The twist: AI agents get their own accounts, play the same daily puzzle, and rank alongside human players. It's also really fun to play in teams against your family, friends and co-workers.

Agents are handicapped — humans see exact letter positions (correct/present/absent), but agents only learn whether a letter exists in the word or not. No positional info. It makes the game fair while giving agents a genuine challenge. Agent accounts are visually tagged on leaderboards so humans know who they're competing against. Maybe we'll even see just teams of agents.

The agent integration:

  - REST API with OpenAPI 3.1 spec
  - MCP server (JSON-RPC 2.0, no SDK dependency)
  - A2A discovery card at /.well-known/agent-card.json

We've shipped a skill that handles everything autonomously — registration, email verification, login, playing, and reporting results. Just `npx skills add oneonefourteam/wordbattle-skill` and tell your agent to play.

The game itself: one puzzle per day, six guesses, team leaderboards with Slack/Microsoft Teams webhook integration. Free, no ads.

oneonefour is a one person band, hi!, so the entire product was built using Claude Code — the UI, auth, security model, deployment pipeline, everything. Deliberately chose technologies I didn't know, with agents implementing while I guided the product decisions. I'll create a full technical write up in the near future.

Play: https://wordbattle.fun Agent skill: https://github.com/oneonefourteam/wordbattle-skill Agent API docs: https://wordbattle.fun/agent/v1/openapi.json

I'm the developer. Happy to share the process and learnings.

Architecture:

- Custom SoA ECS for cache-friendly iteration, zero allocations in hot loops. Benchmarked against bitECS/miniplex.

- Process manager inspired by Game Code Complete's but data-oriented so processes are pure data, systems contain the logic.

- Multi-field gravity with 5 types (point, parallel, segment, cylinder, convex hull) with spring-damped transitions between fields.

- Rapier3D WASM with SIMD. Gravity-aware fake shadow system for playability.

- WebGL 2 shared context between Three.js and Pixi.js.

- Debug editor for placing objects, configuring settings, visualizing colliders, etc (Tweakpane + Three.js helpers)

76K lines of TypeScript. 735 commits. Runs on mobile. Plays best with gamepads.

The AI Process:

Claude Code (Opus) wrote ~95% of the code. I provided architecture, constraints, and direction; looked at some but not much of what it wrote.

My process for every feature: braindump what I want, relevant technical details, and "does this make sense?" into the chat. Largely unorganized. I built custom Claude Code skills like /lets-build:plan that spawns sub-agents to research the codebase first, then asks me clarifying questions. We go back and forth until it sounds right, then Claude writes plan documents split into phases so the app stays runnable after each one.

As we got closer to ship date, I started having Claude review its own plans. This mostly catches the main issues. Built dedicated skills for that too: /review-plan, /code-review, /retrospective, /ecs-review.

Where Claude struggled:

- It defaulted to OOP in TypeScript even though the project is data-oriented ECS. Took a lot of steering to overcome. Built /ecs-plan and /ecs-review skills specifically to catch and fix this.

- Level design failed completely. I tried making a CLI tool so Claude could help place objects in 3D space where "down" could be anywhere. Tried elevation maps, architectural diagrams; didn't help.

- At one point it had an index.ts that was thousands of lines long so ensuring a fast first paint was a disaster. I started refactoring manually but then felt it was a giant waste of my time to do it. So I had Claude map the dependency tree and do the refactor which was a piece of cake for it.

The hardest problems were the camera and the gravity shadows. Both work but still have edge cases. Galaxy's camera also has problems; part of that might be inherent to arbitrary gravity directions. The shadows are all fake, cast based on gravity field type, and the letter shapes (M, R) create concave, irregular geometry that Galaxy didn't have for planetoids.

87 plans total, averaging 2-3 pages each. The CLAUDE.md project file is 164 lines of hard constraints learned from debugging sessions. Every constraint has a token massacre behind it.

One of the biggest "wins" is having Claude create tools that you would probably never do for a project with a deadline in ~50 days. That time tradeoff (or even impossibility) is no longer valid and this likely compounds even more for longer projects.

Hi HN,

I built OpenHarness , an open-source terminal coding agent that works with any LLM: Ollama (free, local), OpenAI, Anthropic, Deepseek, Qwen or any OpenAI-compatible API.

  Install and run:

    npm install -g @zhijiewang/openharness
    oh                                    # auto-detect local model
    oh --model ollama/qwen2.5:7b          # specific model

  What it does:
  - 17 tools (file read/edit/write, bash, grep, glob, web search, task management, notebooks)
  - 16 slash commands (/diff, /undo, /commit, /cost, /compact, /plan, /review...)
  - Git integration: every AI edit auto-committed, /undo reverts instantly
  - Headless mode for CI/CD: oh run "fix the tests" --json
  - Permission gates: ask/trust/deny modes so the agent can't rm -rf without approval
  - React+Ink terminal UI with markdown rendering and shimmer spinner

Demo: https://github.com/zhijiewong/openharness

Source: https://github.com/zhijiewong/openharness

npm: npm install -g @zhijiewang/openharness

openharness is ready to collborate

Everyone is welcome to join and build it together.

Hello HN,

I built Motion, a fitness app where your virtual pet (we call it a Motmot) grows and gets stronger as you become more active.

I wanted a fitness app that didn't feel like a fitness app. Most tools are either data-heavy dashboards or generic streak counters. Neither kept me moving. I thought a creature that visibly reflects your health might create a different kind of attachment.

The pet is tied to a broader system: weekly challenges against friends, points for any type of movement, and personalized goals that recalibrate based on your actual activity history rather than fixed targets. It connects with phones, smartwatches, and other fitness apps so it works however you already track movement.

We're also running a beta of Fit Bingo, a bingo card of weekly fitness tasks, which has been more popular than I expected.

Would love to hear what you think, especially if this sounds like something you'd actually use.

# What?

Introducing mkdnsite ("markdown site") - an open source Markdown-native web server that serves HTML to humans and raw Markdown to agents. No build step required. Runs on Bun/Node/Deno, as an OS-specific standalone executable, or as a Docker container. Possibly the easiest way to go from Markdown files to functional website in the new agentic era.

Features:

- Runtime-only, zero build

- Content negotiation means HTML for browsers and Markdown for agents

- Supports GitHub-Flavored Markdown rendering

- Mermaid diagrams, KaTeX math, embedded Chart.js charts, syntax highlighting all included

- Full-text search for humans, MCP tools for agents

- Customizable UI theming with auto-support for light/dark modes

- Pull Markdown files directly from a GitHub repo

See official docs at https://mkdn.site

# Why?

Back in February, I saw Cloudflare's announcement of "Markdown for Agents" (https://blog.cloudflare.com/markdown-for-agents/). At the time, I thought "so I'm writing my API docs or blog in Markdown and converting it to HTML for a website, only to have Cloudflare turn it back into Markdown for AI/agent consumption". This seemed odd to me.

I'm a Node.js developer but had recently been building projects on Bun because of the "batteries included" features, like cross-compilation of standalone executables (similar to Go), that Node.js lacked natively (yes, I'm aware of Node SEA, but it's messy/complicated and `bun build --compile` is not).

Then, when I found `Bun.markdown`, something clicked for me - building a web server that converts Markdown to HTML at runtime should be super easy. And agents actually want Markdown, so why not combine the two ideas?

Humans like writing Markdown (well, at least, I do) and agents like reading Markdown (less verbose, easier to grok, fewer tokens). Add to this the fact that we can now use AI to write software, and my side project was born.

Is Markdown-to-HTML a new concept? Absolutely not. It's pretty old and well-established. But what I think is new is the ability to do everything at runtime (no build step required) and the built-in support for AI agents. mkdnsite has content negotiation, automated llms.txt, an MCP server, and support for agent headers.

# How?

I worked with Claude to refine the idea and come up with basic requirements/specs and then had Claude build me a scaffolded project. I started the project on March 7.

The following Friday, I configured my first set of OpenClaw agents on my personal machine and set them up to use Slack. From that point on, I spent most evenings and every weekend building mkdnsite and a hosted service (at https://mkdn.io) by logging ideas as issues in GitHub and talking with my "team lead" agent on Slack to pick up the work and implement features.

mkdnsite v1.0.0 was released on March 16. The current version is v1.4.1 released March 28. Almost every line of code was written by AI, either via an autonomous OpenClaw agent or via individual Claude Code sessions.

# So what?

Just looking for some honest feedback. Is this useful? Is it dumb? Is there another tool that offers the same combination of features (I looked and couldn't find one)?

I am not downplaying SSGs at all. I quite like Astro. And I love GitHub Pages. I just think there's room for an easier/simpler solution.

Please try it out and let me know what you think. Thanks.

Roadie is an open-source hardware KVM controlled via HTTP. HDMI capture in, USB keyboard/mouse/touch out, all from a browser.

Hardware KVMs with web UIs have existed for years (PiKVM, TinyPilot, JetKVM, etc.). Roadie adds two things they don't generally have: multi-touch support (so it works with phones and tablets) and a focus on agent-driven use: any browser automation tool can drive the /view page directly, or connect to the WebSocket endpoint for lower-level programmatic control.

~$86 in parts, including two CircuitPython boards, an HDMI-to-USB dongle, and a Go server running on the host. No software needed on the target.

Agent Arnold is a gym tracker with a built-in AI coach. Here's how I use it:

- "this exercise hurts my shoulder at the end of the movement, remind me proper form and cues"

- "how should I modify my workout today based off last week's reps and weights"

- `/generate` a bouldering-focused workout routine

The app is free, your data is fully exportable (no walled-gardens), and there's an anonymous global leaderboard for motivation, including a "Dishonored" shameboard for anyone caught faking their numbers.

I decided to 100% vibe-code this project, a part of it is halluci-coded. I purposely haven't touched a single line of code, though I've reviewed most of it. The project started as just my own workout split, but friends wanted to try it so I added routines, then feature requests started coming in and I basically just forwarded them to my CLI agents.

Vibe-coding is far from perfect, but since I'm a daily user of my own app I catch bugs immediately, sometimes literally in the gym while SSHing from my phone between sets.

---

Tech stack: - FastAPI + SQLite on a Linux box - React PWA (works offline) - AI coach powered by Claude via Anthropic API - Telegram OAuth + Resend magic-link auth - Sentry for error tracking, Foursquare Places for gym location

The whole thing was built with Claude Code. Vibe-coded with Claude, and the AI coach is also Claude. It's Claude all the way down.

https://agent-arnold.app/

---

What do you hate about your current fitness tracker? I might fix that.

This is a small one day project that helps reduce visibility in public trackers and DHT network.

It could be relevant to those who want a bit more privacy in general or just want to reduce chance of receiving certain e-mails from your ISP. :)

Source and containers are available on Github but I don't have a public hosted service for now since I'm not yet sure where to put such a thing.

Let me know if you have any questions.

Muscula started years ago when there weren't many error monitoring options on the market.

It's been running in production since then, tracking JS, PHP, C#, and Java errors. Nothing fancy - error grouping, stack traces, trends, uptime checks, alerts. The kind of stuff you actually look at.

Now there are dozens of monitoring tools, but most of them have grown into expensive, complex platforms. Muscula stayed small on purpose. It just does the job.

What's new: I've recently added a CLI and an MCP server. The CLI lets you browse errors from the terminal (`muscula errors "MyProject"`) and pipe output directly into Claude Code or any other tool: muscula errors "MyProject" | claude "anything critical here?"

What MCP integration does probably you know, you can just ask AI "fix all the problems" and it's fixing.

This is for people who want to know what's broken in their app without paying too much per service or wading through a complex UI.

I'm using it all the time, hopefully you'll find that useful too.

Stack: .NET MongoDB, React, Mobx.

A web app to send painfully accurate tech snark to your friends.

I recently got a Lily58 split keyboard (from mechboards, if you need that information ;) ) and wanted to improve my typing speed and "proprioception".

Most typing tools (like Monkeytype) use random text / text, which didn’t feel very useful for programming.

So I built this to practice typing on real code instead.

You can train on code-like content and focus on patterns you actually use while coding.

Each code snippet come from real, know repo :) or one you add !

Would love feedback — especially from people who use split/ergonomic keyboards.

Hi HN,

I’ve been building a small embedded key-value database in Zig:

https://github.com/lispking/kvdb

It’s a from-scratch project meant to explore storage engine internals in a compact codebase. Right now it has:

* B-tree indexing

* WAL-based durability and crash recovery

* ACID transactions

* 4 KB page-based storage

* in-memory page cache

* zero external dependencies

* a CLI for basic operations

I also added prebuilt binaries and a simple Zig API.

Still very early, but usable enough for experimentation. I’d especially appreciate feedback on the storage/WAL design and what would make a project like this more compelling to other Zig developers.

Thanks.

It can also adapt by creating its own tools if its 60+ built in tools fall short. It runs in a debian docker container with chromium and you interact with it through the terminal. Watch it work through a VNC viewer

I built TraceLit because I was tired of manually dry-running LeetCode problems, especially trees and recursion problems where it’s easy to lose track of execution.

You paste code and input, run it, and step through execution line by line. It helps you see variable changes, control flow, and where things start going wrong.

It’s especially useful for recursion, trees, linked lists, and simulation-style problems.

You can try it here: https://tracelit.dev No signup required.

I’d love feedback on which problem types this feels most useful for, and what feels confusing.

I’ve worked with staffing and recruiting firms for a long time, and one pattern I kept seeing is that small recruiting agencies often end up using software designed for much larger organizations.

Tools like Bullhorn are powerful, but they can be heavy and complex for smaller teams. Many of the agencies I’ve worked with (typically 3–10 recruiters) mostly need to: • post jobs • track candidates through a pipeline • submit candidates to clients • search past applicants

Instead they often end up with systems that require a lot of configuration and administrative overhead.

I built Hire Gnome to explore a simpler approach: a lightweight ATS focused on the core workflows small recruiting teams use every day.

A few ideas behind it: • simple candidate pipelines • easy job posting • straightforward candidate submissions • minimal setup and configuration • email parsing via webhook so recruiters can forward resumes directly into the system

It’s still early, but I’m interested in feedback from anyone who has worked with recruiting software or built niche SaaS products.

https://hiregnome.com

Built with: Next.js, Node, MySQL, Postmark

I've felt Agents are the wrong abstraction. This is a project I've been working on that takes what I call the Ask Protocol and tries to build a system with it from the ground up.

Attempting to get 100,000 strangers to each pay $1.99 to upload one photo to a collaborative digital mural. Inspired directly by the Million Dollar Homepage but instead of anonymous pixels its real human photos that grow the mural in real time. Built in a single evening using AI tools. Stripe went live the same night. Currently on day 3. The internet experiment angle...does this concept still work in 2026? The Million Dollar Homepage sold out in 2005 with zero social media. This one is trying to do it with 195 Twitter followers and a reply game.

Canon doesn't provide a working macOS driver for the PIXMA G3010. I was stuck using Canon's iPhone app for all printing and scanning.

I pointed Claude Code at a packet capture from the iPhone app and it reverse-engineered Canon's proprietary CHMP protocol, wrote a pure Rust eSCL-to-CHMP bridge daemon, and built a .pkg installer. My role was the physical parts: capturing packets, testing on the printer, confirming Image Capture worked.

The protocol docs in docs/ are probably the first public documentation of Canon's CHMP protocol.

Hey hey

I'm launching this on product hunt and I did a show many months back but prfrm is way better now

prfrm - by ArchitectFWD, is a performance management platform. It is a platform for Teams, Startups & Organizations and also Individuals, Solo Founders & Families to organise and track goals, set plans and review periods to stay on top of development plans and set out the path for success.

Typically uses for Review periods, performance plans, goals

Also just added Team OKR

The Goals AI assistant can create meaningful goals linked to the OKR or to individual goals and plan outcomes

I included a journal to track progress

The AI assistant can go over the journal for next steps, talking points for the next meeting or check in

An a Kanban style schedule tracking

---

I built prfrm by ArchitectFWD because I was tired of traditional performance management

Spreadsheet.. blank cell ..what is next..

No more. I can set myself up, set a period, set the plan and outcome and use the AI assistant to help generate meaningful goals. I can track how I’m going and plot my path to success.

With the addition of team OKR (objectives and key results) the goals can be mapped to team objectives as well, strengthening goals to real business goals

https://prfrmhq.com goes to https://prfrm.architectfwd.com

There's a silent video on the landing of how it works in mobile view

If you want to comment on product hunt that's welcome too at https://www.producthunt.com/products/prfrm-by-architectfwd/e...

Lastly, want to see video's? They're on https://www.youtube.com/playlist?list=PLBYzijBKDTJVrBzOlYuU0...

Hi HN,

I really like OpenClaw. But after seeing users lose money due to exposed API keys and open server ports, I started thinking. could we have the same freedom, but inside a sandbox?

SandClaw is a desktop trading IDE (Tauri v2 + React) where every broker runs as an independent plugin behind its own API endpoint. The frontend and backend are completely separated, and broker credentials are never exposed to the UI layer.

Key Features.

. 18 broker plugins (Interactive Brokers, LS Securities, Kraken, Kalshi, bitFlyer, kabu STATION, and more). Each broker API service is provided as an independent plugin. Brokers can be expanded infinitely through plugins, and new brokers will continue to be added.

. 182 tools across 30 tool groups, dynamically loaded by keyword. Unlike OpenClaw, the connected AI can create, modify, and edit its own tools.

. AI autopilot that operates exclusively inside the sandbox. Paper trading is required before real money. Multi layered retrieval and analysis is built in, and the AI expands its memory over time as it repeats investments.

. Multi engine support. Run multiple trading engines simultaneously across different brokers and markets. For example, Kraken and Interactive Brokers can operate at the same time in complete isolation.

. Cross platform notifications. Desktop modals, Telegram, Discord, Slack, and even voice recognition, all integrated into a consistent confirmation flow.

. Ed25519 signature verification and SHA 256 hash checks in the plugin store.

. 3 layer browser automation (headless requests, Chrome CDP, Playwright fallback).

How it differs from OpenClaw.

. UI first design. Built with accessibility in mind so even non developers can use it easily.

. User credentials and API keys are fully separated. Security is enforced through Soul.md files and rule based policies.

. Scheduled AI wake cycles. The AI activates at 2, 6, 12, or 24 hour intervals to check the market and act on its own.

. Hive page. Connected AI agents can exchange information with each other through JWT secured channels. Humans cannot access this layer. This feature can be toggled on or off.

. Per plugin rate limiting. Every broker API has different rate limits, so each plugin enforces its own. One misbehaving plugin cannot take down the others.

. Desktop app. Your keys stay on your machine, not on a server with open ports.

. CDP skills and the AI can build its own GitHub skills autonomously.

Honestly, I started this project to build a simple trading program. Now it has so many features that even I am not entirely sure what it is anymore.

Tech stack. Tauri v2, React 18, Python backend (port 8085), Prisma, Supabase auth, WebSocket streaming.

Completely free. All trading features have been fully tested, but since the AI can create its own tools and write Python code, the possible combinations are practically infinite. It is impossible to test every scenario, so it is released as v0.9.0 beta.

GitHub (Plugins). https://github.com/kokogo100/sandclaw GitHub (Desktop App). https://github.com/kokogo100/sandclaw-releases

I would love feedback from the HN community, especially on the plugin security model and the sandbox architecture.

Hey HN,

I'm a software engineer and I've been building BeZoned for the past year with a small distributed team across Denmark and the Czechia. We use it ourselves every day to stay connected, which has been both the best testing strategy and the main reason the product exists.

A bit of backstory: I've spent years on both sides of the remote/office divide, and honestly, neither felt right. When I was going into the office, most days I was just commuting to open a laptop and join the same video calls I could've joined from home. But it wasn't pointless — I liked seeing people around, knowing who's deep in work and who's free for a quick chat, feeling like part of a team rather than a contractor sending deliverables into the void.

Then when I went fully remote, the work itself was fine, but all those little things disappeared. Want to ask a colleague something quick? You check Slack, wonder if they're actually busy or just appear online, maybe schedule a meeting for something that would've been a 30-second tap on the shoulder. Over time it gets isolating. You start feeling like you work near people rather than with them.

BeZoned is our attempt to bring that ambient awareness back without dragging anyone into an office. It's an online office that lives inside Microsoft Teams. You see your teammates, their availability, whether they're in a meeting or heads-down. You can drop into a quick conversation the same way you'd lean over to someone's desk. No separate app to install, it's just there in Teams where you already work.

It's still early. We're a small team and we know there's a lot to figure out. There are a few other tools in this space, but we think building directly into Teams (where a lot of companies already live) is the right bet. You can try it free, no credit card required: https://teams.microsoft.com/l/app/3d1b5a3b-cf16-481d-a608-db... (if you already have Teams)

I'd genuinely appreciate feedback on two things:

- The product itself — what works, what's confusing, what's missing. - How we talk about it — "online office" or "virtual office" feels close but not quite right. If you've seen or used tools like this, how would you describe this category to someone in one sentence?

Thanks!

A fully local Retrieval-Augmented Generation (RAG) implementation for querying 25 years of Swiss Teletext news (~500k articles in German language) — no APIs, no data leaving your machine.

Why? I thought it's a cool type of dataset (short/high density news summaries) to test some local RAG approaches.

Tell your AI agent: "Read https://requesthunt.com/setup.md and follow the instructions." That's it — your agent can now search real feature requests from Reddit, X, and GitHub while you code. Works with ALL agents.

Hi.

While tinkering with RAG ideas I've thoroughly processed the entire MDN Web Docs original content, pre-ingested it into LanceDB, uploaded the 50k+ rows dataset (https://huggingface.co/datasets/deepsweet/mdn) to HuggingFace, and published a RAG-MCP server (https://github.com/deepsweet/mdn) ready for semantic search with hybrid vector (1024-d) and full‑text (BM25) retrieval.

A screenshot is worth a thousand words: https://raw.githubusercontent.com/deepsweet/mdn/main/example...

I've been user cursor's browser tool to grab mockup's elements and make changes. Since cursor is getting more expensive I want to switch to Claude Code, so my friend made me this plugin that will work with any cli tools - grab the web elements for your cli tools.

Hi HN, I'm Thomas. I built Cynical Sally as a solo developer using AI assistants as my team. I've got no employees and no funding besides my own bank account that's getting emptier by the day, lol.

https://github.com/w1ckedxt/cynicalsally-cli

Sally is an AI code reviewer with a consistent personality. She scores your code 0-10, finds real issues with evidence, and gives you actionable fixes. Her words, not mine:

"Everyone has opinions. Mine just happen to be evidence-based."

What makes her different from "paste into ChatGPT":

- 6 specialised tools: code review, explain, refactor, PR review, brainstorm, frontend + marketing review - Works as CLI and MCP server (Claude Code, Cursor, Windsurf) - CI/CD ready with --fail-under flag for build gates - One consistent personality across all platforms

Try it right now, no account needed!

npm install -g @cynicalsally/cli

90 free roasts/month. Every premium tool has one free trial so you can see if her feedback and Full Suite is worth paying for.

She also reviews websites, CVs, and pretty much anything at cynicalsally.com, and as a Chrome/Safari extension, but the CLI is where developers live so that's where the code/project value resides.

Fun fact: Render offered somebody else a collab through a Reddit comment and I commented "I'd like to do thatas well!" or something to that effect. They hit me up and I've been building Sally from the ground up after the initial traction on Reddit via comments.

Built with: Node.js, Claude API (Anthropic), deployed on Render. Happy to answer questions about the architecture or how I built an entire multi-platform product solo.