Community

682 community available in the Cursor directory

Community discussions, tips, and shared experiences from users of this platform. Join the conversation, ask questions, and share what you've built.

Ask HN: Who build production apps with out seeing code?

Cursor now defaults to agentic mode with no code editor at all, which got me wondering: who is writing or who is building production-grade apps with actual real user traction without ever seeing the code? I can't imagine doing that. At least right now, in the current technology, it's too risky.Are there real examples of people building and shipping real products without ever needing the code editor? Just to clarify, 99% of our code is written by AI, but it's helpful to have the code editor so we can just review and see what changed. VS Code is good for that, but Claude Code and Codex and all the other CLI-based stuff is just not really well optimized for reading code.

amukbils

Show HN: Docs.dev – A docs site you own, where AI drafts and you edit in place

Hi HN. Some backstory, because it explains why this exists.Our startup originally worked on AI-assisted documentation generation. When Claude Code and Cursor's agents matured, we asked ourselves the uncomfortable question: does a standalone "AI writes your docs" product still need to exist? We concluded no, and pivoted to what's now keyboard.dev.That left us with the docs.dev domain. We had a buyer in the docs space lined up and were genuinely excited for it to have a proper home. A month later, they changed their mind. So instead of letting a domain we loved sit parked, we built the docs platform we'd always wanted as a side project.The workflow it's built around: coding agents already write documentation well, but reviewing agent-written docs in raw MDX is miserable. So with docs.dev, Claude Code updates your docs template in the same session where it ships your code (the template carries a CLAUDE.md and skills, so it knows the conventions). Then you go to your actual docs site, on your domain, log in as an admin, and review the page exactly as readers will see it. Anything the AI got wrong, you edit or delete in place, directly on the live site. Publishing is a git commit to your repo, and CI redeploys. The same URL serves readers and, for admins, becomes the editor.The economics are the other half of the pitch. There's no hosting on our side and no content database: one click clones the template into your GitHub account and deploys it to your Cloudflare account with push-to-deploy CI. AI writing, image generation, and chat run on Cloudflare's own primitives (Workers AI and friends), billed at Cloudflare's rates on your account. You're not paying a docs vendor to host your own documentation, and you're not paying their markup on AI calls. The optional docs.dev service adds exactly one thing, team sign-in, and it's a sign-in check, not a dependency: if we disappear tomorrow, your site keeps serving.We deliberately built on existing technology rather than reinventing it: Fumadocs (Next.js + MDX) for the docs framework, chenglou's pretext layout engine for the reading experience (prose flows around figures like a magazine spread, while the server still renders plain indexable text for crawlers and no-JS readers), and Cloudflare's out-of-the-box platform pieces for deploys, CI, and AI.Honest caveats: it requires the Cloudflare Workers Paid plan ($5/mo) because the server Worker is ~5.3 MiB gzipped, over the free plan's 1 MiB limit. It's a side project, not our main company. And the magazine-style layout is the kind of thing you either love or find gratuitous. We'd genuinely like to hear which.There's a walkthrough video on the homepage if you'd rather watch the workflow than read it. Happy to answer questions about the agent workflow, the in-place editing, the ownership model, or the pivot. Note it is an early but hope this helps people that wants easy, cheap, and effective documentation on their terms

linktothenew

Show HN: AI harness for C/C++ with GDB, sanitizers, perf and compile tools

hey guys, i wanted to show one of my side projects.The idea is a coding harness (independent of models) natively designed for C/C++ developer workflows.I'm a C++ dev and do not find claude code work well with C++ toolchain like gdb and perf. The current version has integrations for gdb, clang-tidy, cppcheck, sanitizers, perf, benchmarking, compile DB navigation, Godbolt, symbolization, binary inspection, and decompilation.It supports Anthropic, OpenAI, Gemini, and self-hosted models. There are editor workflows for VS Code, CLion, emacs, neovim, and cursor.

anirudhak47

Show HN: Gist Discover – TikTok for ArXiv Summaries

Dunno about you, but I cannot keep up with the volume of AI research. Reading one paper properly takes 30–60 minutes, and it's hard to know which are even worth it.I built Gist, an AI summarizer for ADHD brains. Each paper is a clean slide deck with four layers you move through:1. the Gist – the whole idea 1-2 sentences 2. Logic – breakdown of the argument + evidence in discrete ideas 3. Counter-Argument – strongest argument against the author (AI generated) 4. Steelman – transcendent rebuttal to the counter-argument (AI generated)There's integrated TTS audio too — hit play to listen.I went overboard and post-trained a model specifically for this.When I say I went overboard, I really did! I burned $130k of AWS Claude credits on the dataset, 1/3rd of which is Arxiv papers. My goal was to absolutely max out on data quality over quantity. And it worked!I started with a looping 5-step multi-teacher editorial pipeline using Claude Opus 4.6 & Gemini 3.1 Pro, then distilled it into Gemini 2.5 Flash single shot model that (according to my evals) beats all the best single-shot frontier model for this task on quality (while being 20x faster and 10x cheaper).Here's a random one from the feed right now:Qwen-Image-Agent: Bridging the Context Gap in Real-World Image GenerationQwen-Image-Agent scores 45.4 on a benchmark where the direct image generator it's built on scores 17.4 — a 161% improvement from the same model, same weights, same prompt. The difference isn't better pixels. It's a system that asks "What else do you need?" before it ever draws a single one.gist.is/discover is a free feed of all the arXiv papers I've run through it. No signup. Right now, the feed is totally random, but if this gets traction I'll build a proper recommendation system.Read the gist in ~10 seconds and go deeper if you want (inc going straight to the source), or tap Next→ and try again.I also created Gist Discover extensions for your IDE so you can read / listen / learn while your AI agents work.Cursor/Windsurf: <a href="https://open-vsx.org/extension/Transcendence/gist-discover" rel="nofollow">https://open-vsx.org/extension/Transcendence/gist-discover</a>VS Code: <a href="https://marketplace.visualstudio.com/items?itemName=Transcendence.gist-discover" rel="nofollow">https://marketplace.visualstudio.com/items?itemName=Transcen...</a>Feedback welcome! Enjoy! -Matt

MediaSquirrel

Show HN: OpenKnowledge – open source AI-first alternative to Obsidian/Notion

Hi HN, Nick here. We’re launching OpenKnowledge (<a href="https://openknowledge.ai/" rel="nofollow">https://openknowledge.ai/</a>), a “what you see is what you get” markdown editor that has direct integrations with Claude, Codex, and other agents. Available as MacOS app or Web UI+CLI. Fully free/local and OSS.We built this because we wanted a Notion-like experience for writing and sharing markdown files across our team. Obsidian is the best alternative we tried, but found it doesn’t have a true WYSWIG UI and it didn’t integrate well with Claude/Codex outside of community plugins.So we built OpenKnowledge. It takes shape as:1. A MacOS app with a file navigator, the WYSIWYG editor, and link explorer.2. Integrations with the Claude, Codex, and Cursor desktop apps. The agents can open an OpenKnowledge editor within their embedded web browsers for a side-by-side experience.3. Built-in mcps, skills, and RAG for LLM-wiki and “AI Second Brain” scenarios + spec writing4. An embedded terminal and CLI for TUI-first usersOSS stack includes: Tiptap/prosemirror, CodeMirror, yjs (CRDT), Electron (MacOS app), Orama, remark/rehype/micromark/mdast, @pierre/treesOn the architecture side, the interesting eng. challenges included:1. A pipeline to convert ProseMirror to markdown in a bidirectional lossless way. ProseMirror uses ASTs, which are not designed to have byte-fidelity.2. A dual-observer CRDT to keep the ProseMirror and markdown state in-sync.The CRDT + git also power a collaborative experience that shows what Agents are doing in the markdown, have undo/redo, and version history. The “Share” and cloud-sync functionality are geared for team collaboration. They feel “no-code” but leverage git/GitHub under the hood, which also means data stays fully private.In that spirit, we made OpenKnowledge open source for anybody who’s curious or who’d like to contribute.We’re actively thinking about plugins/extensibility and what’s next. If you have suggestions or feedback, would love to hear it.

engomez

381

Show HN: writing tasks with focused context + instructions = sharper AI

To get an AI to do a task well, you need to give it the right context and the right task description. I've had a lot of struggles working in a large codebase getting AI to follow the existing patterns and architecture. So I started building a VS Code / Cursor extension that lets you quickly snap together sub prompts/instructions relevant to a specific task. After seeing the value of this, I realized you could make those sub prompts more customizable by using a liquid syntax engine.That worked fine for a few days, until the original context blocks got stale as the project progressed. I wrote an MCP server that can update those blocks, creating a feedback loop. A few days later I added an amend option too, so the AI can write a log and decision record as it goes.At this point I realized there were a lot of opportunities here: my AI isn't spending the first 5 minutes doing research, I've got better control over my context window, there's less irrelevant data leaking in from my agents.md file when I switch repos, I can write prompt groups for separate workflows, and so on. The last blocker for me was that I actually use Claude Code and not VS Code much anymore. So I figured out how to hook into the external editor command to open a TUI directly from CC and write a prompt from there.Now I'm happy to finally share it after spending the last 5 months perfecting it. Would love for you to try it and let me know what you think, even if its not something for you - why?More details see GH: <a href="https://github.com/simondevries/prompt-foundry" rel="nofollow">https://github.com/simondevries/prompt-foundry</a>install vscode: <a href="https://marketplace.visualstudio.com/items?itemName=sdevries.prompt-foundry" rel="nofollow">https://marketplace.visualstudio.com/items?itemName=sdevries...</a>Install OpenVsx: <a href="https://open-vsx.org/extension/sdevries/prompt-foundry" rel="nofollow">https://open-vsx.org/extension/sdevries/prompt-foundry</a>

espresso_dev

Show HN: Nib, collaborative font editor on the web

hi hn! Title basically covers it. I made Nib over the course of about a year and a half. It's a collaborative font editor, kind of like figma but for type design instead of UI design. Also has AI features for generating glyphs, versioned export, font import, advanced bézier curve editing features...and cursor chat. Among other features. Lemme know if you find any bugs!

johnnydamacha

Show HN: Statewright – Visual state machines that make AI agents reliable

Agentic problem solving in its current state is very brittle. I fell in love with it, but it creates as many problems as it solves.I'm Ben Cochran, I spent 20+ years in the trenches with full-stack Engineering, DevOps, high performance computing & ML with stints at NVIDIA, AMD and various other organizations most recently as a Distinguished Engineer.For agents to work reliably you either need massive parameter counts or massive context windows to keep the solution spaces workable. Most people are brute forcing reliability with bigger models and longer prompts.What if I made the problem smaller instead of making the model bigger?I took a different approach by using smaller models: models in the 13-20B parameter range and set them to task solving real SWE-bench problems. I constrained the tool and solution spaces using formal state machines. Each state in the machine defines which tools the model can access, how many iterations it gets and what transitions are valid. A planning state gets read-only tools. An implementation state gets edit tools (scoped to prevent mega edits) and write friendly bash tools. The testing state gets bash but only for testing commands. The model cannot physically skip steps or use the wrong tool at the wrong time. It is enforced via protocol, not via prompts.The results were more promising than I would have expected. Across multiple model families irrespective of age (qwen-coder, gpt-oss, gemma4) and the improvements were consistent above the 13B parameter inflection point. Below that, models can navigate the state machine but can't retain enough context to produce accurate edits. More on the research bit: <a href="https://statewright.ai/research" rel="nofollow">https://statewright.ai/research</a>Surprisingly this yielded improvements in frontier models as well. Haiku and Sonnet start to punch above their weight and Opus solves more reliably with fewer tokens and death spirals. Fine tuning did not yield these kinds of functional improvements for me. The takeaway it seems is that context window utilization matters more than raw context size - a tightly scoped working context at each step outperforms a model given carte blanche over everything. Constraining LLMs which are non-idempotent by using deterministic code is a pattern that nobody is currently talking about.So, I built Statewright. Its core is a Rust engine that evaluates state machine definitions: states, transitions, guards and tool restrictions. Its orchestration doesn't use an LLM, just enforces the state machine. On top of that is a plugin layer that integrates with Claude Code (and soon Codex, Cursor and others) via MCP. When you activate a workflow, hooks enforce the guardrails per state automatically. The model sees 5 tools available instead of dozens, gets clear instructions for the current phase and transitions when conditions are met. Importantly it tells the model when it's attempting to do something that isn't in scope, incorrect or when it needs to try something else after getting stuck.You can use your agent via MCP to build a state machine for you to solve a problem in your current context. The visual editor at statewright.ai lets you tweak these workflows in a graph view... You can clearly see the failure paths, the retry loops and the approval gates. State machines aren't DAGs; they loop and retry, which is what agentic work actually needs.Statewright is currently live with a free tier, try it out in Claude Code by running the following:/plugin marketplace add statewright/statewright/plugin install statewright/reload-pluginsThen "start the bugfix workflow" or /statewright start bugfix. You'll need to paste your API key when prompted. The latest versions of Claude may complain -- paste the API key again and say you really mean it, Claude is just being cautious here.Feedback is welcome on the workflow editor, the plugin experience, and tell me what workflows you'd want to build first. Agents are suggestions, states are laws.

azurewraith

126

Show HN: SkillCatalog, a Git-native skill manager for AI coding tools

AI coding tools like Claude Code, Cursor, and Codex read instructions from files on disk: .claude/skills/, .cursor/skills/, .agents/skills/. These files shape how each tool behaves. On a team of ten engineers working across several repositories, managing them by hand breaks down fast.I built SkillCatalog to solve this without a SaaS dependency. Skills live in Git repositories the team already controls. The desktop app provides authoring, organization, and delivery on top of Git. Access control is Git access. There is no server to run and no data leaves the machine unless you push it.The model is different from Microsoft's APM, which takes a package-manager approach (declare in apm.yml, everyone installs the same set). I think skills are closer to editor preferences than packages: there is a shared team baseline, but individuals layer their own selections on top. A project profile might install the team's backend bundle for everyone, while one engineer adds a personal stack for performance profiling and another adds one for accessibility auditing. Neither edits the shared catalog.Catalogs contain skills (Markdown with frontmatter) that compose into stacks (ordered lists of skills) that compose into bundles (ordered lists of stacks). Profiles pick what gets delivered. Home profiles apply everywhere; project profiles inherit from them with project-specific selections taking priority. The app detects drift if someone hand-edits a delivered file, which helps when debugging unexpected AI behavior.Stack: Rust Tauri v2 desktop app with React frontend, a skc CLI for scripting and CI. macOS via Homebrew for now, Linux and Windows coming.Happy to answer questions. Particularly interested in hearing from teams who are currently managing these files in other ways.

sformisano

Ask HN: Agents Craving Context

Hey, I was an early adopter of the Cursor IDE and pretty much installed it day 1 of it's public release. Like many I've been using LLMs to help accelerate the writing of code in my own company and side projects and have been quite optimistic and satisfied with the quality and experience of using the Cursor IDE chat -> composer -> agents to enhance the developer experience.However, recently it seems like there has been a shift in how agents work (I am mainly referring to using Cursor agents here but the seems to also apply for Claude Code). When I introduce a problem to the agent a while ago it used to just start writing code. I remember having to be explicit about selecting the files or even lines I wanted it to edit or generate code in, and be quite precise in supplying the LLM with the relevant context. These days I will write a similar prompt to what I would do before: "Refactor X.ts into separate files /utils/[module].ts using the /shared/utils directory as an example". (just a toy example)Now, instead of just reading the examples I feed it and the context I provide, the agent will read the files and notice the imports, it reads into which imports may be important and then goes into the node_modules and reads the library code and then realizes there are docs linked and then it asks to fetch the docs linked there then in the docs there is a reference to another library so it needs to fetch that library which links to a Github page which it needs to read before realiing.. wait what was the task again? Oh yeah refactoring this. But wait now I need to read all the files that rely on this to make sure that I can refactor those correcly once I make these changes... and so on.This was not the case even just 1 year ago. Before I was able to do a clear job defining the task and the LLM would do the task with the provided information. Sometimes I would provide the wrong information and it would do the task wrong and I could undo, fix the information and have to do the task again, or I could manually go in a fix the issues. Now, the agents are consuming huge amounts of context and taking incredibly large amounts of time to produce "correct" code where in my experience the 1-shot accuracy seems to only have marginally improved due to the fact that when they finally get to the step of generating code there is so much extraneous context in their prompting that can cause artifacts or issues in the actual generated solution, not to mention the fact that a simple request will take maybe a full minute to change some code in 1 file...Anyways apologies for the rant but I was wondering if anyone else is experiencing similar changes to the AI coding space and if they have come up with solutions for it? (Caveman mode maybe ? :))

AnthonyR

Show HN: Hormuz Trail - Oregon Trail parody/black-box AI coding exercise

I jokingly told a co-worker Iran might make a good Oregon Trail parody. Then I built it.I wanted to see how far I could go black-boxing the app with AI. I expected a weekend of work, but getting it right took:- Three weekends- ~ $150 in Cursor spend- $50 for asset creation (Layer.ai)Core learnings:- No single model or provider is sufficient at this point. Opus + GPT 5.4 for planning. Cursor Composer for coding. Sonnet for review and more difficult stuff. Gemini 3.1 for UI and UX- I spent probably twice as much in time and tokens as I needed to - setting up a Figma-Claude MCP feedback loop would have saved me a lot of work on UI tweaks and revisions. Knowing what I wanted when I started would (obviously) have helped too.- Layer.ai was worth it for asset generation. I'll bet I could have figured out prompts given enough time, but I was able to just jump in and make the visuals and sprites I wanted for cheap.- It's worth building out skills and commands, even for throwaway projects.- Cursor Composer is worth staying on Cursor instead of just moving over to Claude Code/Desktop/etc. Really straightforward, clever solutions to some problems, doesn't editorialize my UI text- As a counterpoint to Composer, I can't tell you how often I'd have Sonnet do something, and then find an extra paragraph or two of UI text on a screen where Sonnet thought maybe we needed to tell the user exactly how scoring works.- I need to learn some more sea shanties.Final notes:- I'm an SDET, and in one way black-boxing with AI honestly just feels like another day for me - work with the PM for requirements, send to the dev team, test, repeat. On the other hand, having an agent build a 10k scenario simulation engine for tuning the game parameters in 10 minutes was mind-blowing.- AI changes the calculation of what's worth my time. 6 months ago I would have laughed about the idea of HT, then went on with my day.

sstradling

Someone did a deep dive into Cursor Agent and discovered that it was literally just Claude Code with a process that does search and replace to brand it as Cursor Agent

https://gist.github.com/jasonkneen/4c065df2d7a95610e4fd30c3e3398b17

DrySalamander9728

178

Ask HN: Anyone else went through the AI-editor carousel back to the terminal?

My path over the last year or so:<pre><code> Cursor → Windsurf → VSCode + Claude → Warp → cmux → nvim + Claude Code </code></pre> Short version of what didn't stick:- Cursor: felt like a worse VSCode with AI bolted on- Windsurf: laggy enough to break flow- VSCode + Claude extension: actually the best of the bunch for a while, but started feeling like overkill once I realized 90% of what I used was the editor + chat sidebar- Warp: opinionated block UI and telemetry never sat right- cmux: lags unbearably, and I ended up babysitting parallel agents more than codingDropped all the way down to nvim with Claude Code as a sidebar and that's been the stickiest by a wide margin. Feels closer to pair programming than to orchestration or autocomplete.Current stack:- Ghostty (native splits, no multiplexer) + moonfly theme- zsh + Starship, zoxide/eza/bat/fd/rg, fzf history- Neovim on kickstart.nvim with lualine, neo-tree, telescope- Claude Code as an nvim sidebar, via subscription (not API)Dotfiles: https://github.com/Doldrums/dotfilesQuestions:1. Anyone else went through the carousel and came back to a plain editor? Or did one of them actually stick?2. Sidebar chat vs inline Cursor-style vs ghost autocomplete which mode of AI actually helps you ship?3. For people still on VSCode + Claude extension, am I missing something by dropping to nvim, or is it really just taste?4. Anything I haven't tried that I should? Helix, Zed, Aider, Continue, I keep seeing these mentioned but haven't made the jump.What did you try that didn't stick?

amoriodi

How I use Cursor 10+ hours a day without torching my Claude Opus 4.6 limits

Anyone else here doing full-stack Next.js in Cursor and watching the Claude quota evaporate before lunch? I used to be in the same boat — massive context windows from all the components, pages, and DB logic would smoke the default limits fast. Not anymore. I’ve been on this setup for weeks and basically never hit a wall while still getting top-tier answers. Here’s exactly what I do: 1. .cursorrules is non-negotiable I keep one in the root of every project. The key line I added: “Never explain the code to me. Just output the code blocks.” That single rule saves me thousands of output tokens a day. No more walls of “here’s what I changed and why” — just the goods. 2. Stopped using Cursor’s built-in Claude quota I killed the default Cursor Pro subscription for the heavy stuff. Instead I use my own API keys and point Cursor’s “OpenAI Compatible” base URL at LLM Router Gateway. Inside llmrouter routing settings I set up simple tags routing like this: UI & CSS tweaks: gemini-3.1-flash → gpt-5.4-mini Deep backend / complex logic: claude-opus-4.6 → deepseek-v3.2 General / quick questions: llama-4-scout I sorted the fallback chains by speed vs intelligence. The router auto-detects the query type, so 90% of my UI polish and small fixes go to Gemini (basically free + huge context). I only actually hit Claude Opus 4.6 when I’m doing nasty database refactors or tricky architecture stuff. My Anthropic bill dropped \~70% overnight. 3. Cmd+K for everything small Don’t open the full chat sidebar just to rename a variable or extract a component. Highlight the code, hit Cmd+K, let a fast model handle the inline edit. Saves a ton of tokens and feels way snappier. That’s it. Super simple but it completely changed how much I can actually use Cursor in a day. How are you all managing the limits? Using a Cursor Team? Or did you build your own router hacks too? Drop your setups — always looking to steal better ideas.

Youssef_Wardi

310

Cursor V3 is a significant regression

So I used to be a big cursor fan - striked the right balance between trusting the AI and being able to check the work. The new version however, sucks. Worktrees are now essentially AI initiated magic git commands that require manual approval, which is slow and annoying, and means I have to read through a bunch of git guff, and I have to wait like a minute before it does any real work for it to essentially do something that can be duplicated with a script, and it doesn't work well half the time - it had to retry twice to apply worktree changes! The new agent screen is pretty useless, because now you need to go and select a bunch of information that previously would be entirely obvious from context i.e. alt-tabbing into a specific repo's IDE. I don't like this direction and if they continue, I might start looking at competitors. Cursor is clearly aimed at and used by developers who can read code and want to read the code produced by AI. I use Claude Code if I want to just trust the AI.

ExaminationNo8522

212

Introducing Cursor 3

We’re introducing Cursor 3. It is simpler, more powerful, and built for a world where all code is written by agents, while keeping the depth of a development environment. With the new Cursor, you can run as many agents as you want, everywhere you want: locally, in a worktree, on remote ssh, and in the cloud. And it has the best parts of the editor available when you need them. The new interface is available as a separate window that complements the IDE. Update Cursor to try it. We recently launched Composer 2, a frontier model with high limits. Then, with cloud, we gave agents their own computers so they can work truly autonomously. And now with Cursor 3, we’re releasing a new interface to collaborate with agents on software.

lrobinson2011

184

Cursor 3 out now

Graniteman

125

Show HN: I/Claude reverse-engineered Figma's binary WebSocket protocol

Disclaimer: this is vibe-coded — (<- I lost you there) the README, most of the code, and the binary format reverse-engineering were done with Claude. But the tool works and I use it everyday for some days now. As Baudelaire said "qu'importe le flacon, pourvu qu'on ait l'ivresse."~I~ Claude built a tool that decodes Figma's internal binary protocol (Kiwi format over WebSocket) to extract the full scenegraph — every node, vector path, and style — without hitting the REST API.Why: Figma's REST API has aggressive rate limits. The official MCP server requires a paid Dev Mode plan. I needed to explore designs from my AI coding tools without constantly getting 429'd.It helps me to:<pre><code> 1. extract the svg in a clean way (even the SVG export from figma likes to write the path as 12.0000001, even though the protocol does have 12 in it) and images 2. Get mapping from what I see in figma <-> what i see in the exported html 3. It helps me help our designer to produce an actual "resizable" figma, so that they finally understand the pain of "ok it works when you click play on the iphone 17 frame you put, but what about an iphone12 ?" (I was always able to say that, but before I wasn't able to point out what was wrong, now I can) </code></pre> How it works: When you open a Figma file in the browser, the editor loads the entire scenegraph via WebSocket as Kiwi-encoded binary frames. This tool captures those frames via Chrome DevTools Protocol, decodes the binary data (including two undocumented vector formats), and gives you structured JSON.What Claude reverse-engineered:<pre><code> - The fig-wire frame format (schema delivery over WebSocket) - commandsBlob: Figma's pre-computed SVG path commands (MoveTo, LineTo, CubicBezier, ClosePath) - vectorNetworkBlob: the editable path data (vertices, segments with Bezier tangent handles, regions with loops) - All three are documented as Kaitai Struct specs (.ksy) so you can generate parsers in any language </code></pre> Ships as: JS lib (zero deps), CLI, MCP server (Cursor/Windsurf/VS Code), and Claude Code plugin.Binary format specs, sample fixtures, and everything else: <a href="https://github.com/allan-simon/figma-kiwi-protocol" rel="nofollow">https://github.com/allan-simon/figma-kiwi-protocol</a>I'm not a lawyer but my understanding is this is an interoperability tool under EU Directive 2009/24/EC Article 6. No Figma code is included: it only decodes the wire format of data transmitted to your own browser.

allan_s

They kinda cute

sugandalai

828

"Now I see the issue!"

Anyone got any workarounds to this? Got the meme from ijustvibecodedthis.com (the AI coding newsletter thingy)

Complete-Sea6655

423

Show HN: Vectimus – Cedar policy enforcement for AI coding agents

Hey HN. I built Vectimus because coding agents keep doing things they shouldn't and there's no runtime governance layer for the developer workstation.The problem: Claude Code, Cursor, Gemini CLI and GitHub Copilot let agents execute shell commands, write files and call MCP servers. Most developers disable the permission prompts because they slow you down. But that means the agent can rm -rf /, read your .env, push to production or call a compromised MCP server with nothing watching.Vectimus intercepts every tool call and evaluates it against 78 Cedar policies containing 369 rules before execution. Cedar is the policy language AWS chose for AgentCore Policy (GA this month). Evaluation runs locally via a persistent daemon in under 10ms. Zero network calls. Zero telemetry. Every evaluation produces an Ed25519-signed receipt so you have cryptographic proof of what was allowed and denied.Every policy maps to a real incident. CVE-2025-6514 compromised 437,000+ developer environments through a malicious MCP OAuth proxy. The GitHub MCP server was hijacked via a crafted issue to exfiltrate private repo data. A Terraform agent destroyed production infrastructure. These happened.How it hooks in: Claude Code intercepts shell commands, file writes, MCP calls and web fetches. Cursor governs shell commands, file reads/writes and MCP tool calls at the editor level. Copilot intercepts terminal commands, file edits, deletes and git pushes. Gemini CLI uses Gemini's native hook system. MCP servers are blocked by default and allowlisted per-project with input inspection. Observe mode lets you see what would be blocked before you enforce.I also built Sentinel (<a href="https://github.com/vectimus/sentinel" rel="nofollow">https://github.com/vectimus/sentinel</a>), a three-agent pipeline that scans for new agentic AI security incidents daily, drafts Cedar policies, replays the incident in a sandbox to prove the policy catches it, then opens a PR. The pipeline is governed by Vectimus. Every finding and policy draft is public.All 10 OWASP Agentic Top 10 categories covered. Compliance annotations for SOC 2, NIST AI RMF, NIST CSF 2.0, EU AI Act, ISO 27001, CIS Controls and SLSA. Apache 2.0. Solo founder, built in Ireland.Happy to go deep on the Cedar policy design, the hook architecture, the signed receipts or the OWASP mapping.

JXavierH

Show HN: FlowScript – Agent memory where contradictions are features

There is a shortfall to our current approach to agent memory. Right now, we are just collecting flat facts across a flat memory surface and creating vectorized chains of ambiguity, then wondering why when we ask an agent why it did something the best answer we can get is a probabilistic half-hallucinated half-answer that does not address the actual details of the issue, because it is simply pattern matching to find untyped similarities.So I built FlowScript.FlowScript is a typed reasoning graph that your agent builds through tool calls during your everyday work. It is NOT a graph database. What it is is a small set of unique opinionated primitives: things like thoughts, questions, decisions, blockers, and each of those have typed relationships between them. Your agent calls the tools as it works and it builds this typed graph, and then afterwards you can query that structure to get actual deterministic answers using five queries: tensions, blocked, why, whatIf, alternatives.What does this look like in practice? Here's an agent that has been reasoning about database choices for a few sessions:<pre><code> > mem.query.why("node_postgres_decision") PostgreSQL chosen ← "Need ACID for payment processing" ← "Original requirement: handle refunds atomically" ← "Stripe webhook failures in staging revealed race condition" > mem.query.tensions() ><[performance vs cost] "Redis: sub-ms reads critical for UX" vs "Redis cluster: $200/mo for 3 nodes" </code></pre> The why chain traces back to the original constraint and the tension preserves the actual tradeoff being made. These are things no vector store can do, because they are NOT just flat facts, but are relationships and reasoning chains that are being captured in a deterministic way. Meaning you can actually go back and audit the actual reasoning of your agent, how it evolved over time, and see the actual tensions that were being balanced. No more opaque reasoning that is lost as soon as the polished answer is generated. Try that in any other memory system, I'll wait.Other memory systems, when they come across a tension or a contradiction, for the most part they are just simply deleting that. And that is wrong because that tension is new knowledge. Knowledge that we need to actually keep for auditing and because it tells us about the evolution of the system and its cognition over time. So instead of deleting contradictions, we relate and create named relationships for them. Relationships you can query.Every decision, every tension, every piece of reasoning is being deterministically captured into an audit trail and hash-encoded. Now, not only do you have a deterministic reasoning chain, but that reasoning chain is auditable. You can go back to any point within the time that you have audit logs for and deterministically review and understand the actual reasoning chain that your model was using. Something that no other system can offer. The EU AI Act is going to require exactly this kind of transparency by August 2026, and as far as I can tell, FlowScript is the first open source agent memory system that is designed to meet that bar.Try it NOW: Our MCP server in Claude Code or Cursor. Install and check our Get Started guide so you can add one JSON block to your editor config and drop a snippet into your project CLAUDE.md file, then restart. Your AI assistant gets a full set of reasoning tools that actually trace causality.<pre><code> pip install flowscript-agents openai </code></pre> See flowscript.org for full setup instructions: <<a href="https://flowscript.org/get-started" rel="nofollow">https://flowscript.org/get-started</a>>Or grab the TypeScript SDK for programmatic use:<pre><code> npm install flowscript-core </code></pre> There are drop-in adapters for LangGraph, CrewAI, Google ADK, and more Python agent frameworks. MIT licensed. Open source.Repo: <<a href="https://github.com/phillipclapham/flowscript" rel="nofollow">https://github.com/phillipclapham/flowscript</a>> Docs: <<a href="https://flowscript.org" rel="nofollow">https://flowscript.org</a>> Python SDK: <<a href="https://github.com/phillipclapham/flowscript-agents" rel="nofollow">https://github.com/phillipclapham/flowscript-agents</a>>

phillipclapham

i tried Claude and now i understand why people say their agent run for hours

so i am using cursor for over 6 month now and the company that i work gave us Claude code. i always saw in in social media how people brag that Claude run for hours without stopping and for me the longest session with cursor was 20-30 minutes with no stops. so long story short now i understand why it just that Claude code is so fucking slow

Basic_Construction98

167

Instant Grep in Cursor

Cursor can now search millions of files and find results in milliseconds. This dramatically speeds up how fast agents complete tasks. We're sharing how we built Instant Grep, including the algorithms and tradeoffs behind the design. https://cursor.com/blog/fast-regex-search

lrobinson2011

165