Cursor

Cursor AI

Cursor AI

Cursor AI

Cursor AI

Cursor AI

Cursor AI

Cursor AI

Cursor AI

Cursor AI

Cursor AI

Curated 550+ free AI tools useful for building projects (LLMs, APIs, local models, RAG, agents)

Over the last few days I was collecting free or low cost AI tools that are actually useful if you want to build stuff, not just try random demos. Most lists I saw were either outdated, full of affiliate links, or just generic tools repeated everywhere, so I tried to make something more practical mainly focused on things developers can actually use. It includes things like free LLM APIs like OpenRouter Groq Gemini etc, local models like Ollama Qwen Llama, coding tools like Cursor Gemini CLI Qwen Code, RAG stack tools like vector DBs embeddings frameworks, agent workflow tools, speech image video APIs, and also some example stack combinations depending on use case. Right now its around 550+ tools and models in total. Still updating it whenever new models or free tiers appear so some info might be outdated already. If there are good tools missing I would really appreciate suggestions, especially newer open weight models or useful infra tools. Repo link https://github.com/ShaikhWarsi/free-ai-tools If you know something useful that should be included just let me know and I will add it. submitted by /u/Axintwo [link] [comments]

Tampermonkey transcript code

Whats up. Just dropping this in here. Use this to get named transcripts from claude chats in Tampermonkey on firefox. // ==UserScript== // u/nameClaude Chat Transcript Downloader v3 // u/namespacehttp://tampermonkey.net/ // u/version3.0 // u/description Download current Claude chat as a formatted transcript // u/matchhttps://claude.ai/* // u/grantnone // ==/UserScript== (function () { 'use strict'; function addButton() { if (document.getElementById('transcript-dl-btn')) return; const btn = document.createElement('button'); btn.id = 'transcript-dl-btn'; btn.textContent = 'Download Transcript'; btn.style.cssText = ` position: fixed; bottom: 80px; right: 20px; z-index: 9999; padding: 8px 14px; background: #1a1a1a; color: #fff; border: none; border-radius: 8px; font-size: 13px; cursor: pointer; opacity: 0.85; `; btn.addEventListener('click', downloadTranscript); document.body.appendChild(btn); } function extractText(el) { const tags = el.querySelectorAll('p, li, h1, h2, h3, h4, pre code, td'); if (tags.length) { return Array.from(tags).map(n => n.innerText.trim()).filter(Boolean).join('\n'); } return el.innerText.trim(); } function downloadTranscript() { const lines = []; // Collect all user message bubble containers const userBubbles = new Set(); document.querySelectorAll('[data-testid="user-message"]').forEach(el => { // Walk up to the bg-bg-300 bubble let node = el; while (node && !node.className?.includes?.('bg-bg-300')) { node = node.parentElement; } if (node) userBubbles.add(node.parentElement); // the flex-col wrapper }); // Get the main chat container — find common ancestor of all user messages const allUserMsgs = document.querySelectorAll('[data-testid="user-message"]'); if (!allUserMsgs.length) { alert('No messages found. Make sure you are on a chat page.'); return; } // Walk up from first user message to find the chat scroll container let container = allUserMsgs[0].parentElement; for (let i = 0; i 2) break; container = container.parentElement; } // Now iterate direct children of the container // Each child is either a user turn (has .bg-bg-300 descendant) or a Claude turn const turns = Array.from(container.children); turns.forEach(turn => { const userMsg = turn.querySelector('[data-testid="user-message"]'); if (userMsg) { const text = extractText(userMsg); if (text) { lines.push('─────────────────────────'); lines.push('[YOU]'); lines.push('─────────────────────────'); lines.push(text); lines.push(''); } } else { const text = extractText(turn); if (text && text.length > 10) { lines.push('═════════════════════════'); lines.push('[CLAUDE]'); lines.push('═════════════════════════'); lines.push(text); lines.push(''); } } }); if (!lines.length) { alert('Could not extract messages.'); return; } const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19); const blob = new Blob([lines.join('\n')], { type: 'text/plain' }); const a = document.createElement('a'); a.href = URL.createObjectURL(blob); a.download = `claude-transcript-${timestamp}.txt`; a.click(); URL.revokeObjectURL(a.href); } window.addEventListener('load', addButton); new MutationObserver(addButton).observe(document.body, { childList: true, subtree: true }); })(); submitted by /u/Whole_Win5530 [link] [comments]

Claude Code can now see and control your code editor.

Been shipping updates fast on claude-ide-bridge and wanted to share what's new. The big additions: Claude can now leave notes directly in your editor as you work, instead of dumping a wall of text in the chat, it highlights the exact lines it's talking about "Show me everything that calls this function" now actually works, Claude traces the full chain up and down through your code Claude can take a change all the way from your editor to a finished GitHub pull request in a single session, no manual steps Claude runs your tests, reads what broke, fixes it, and runs them again on its own One command (claude-ide-bridge init) sets everything up automatically, detects your editor, installs what's needed, and configures itself Works with VS Code, Windsurf, Cursor, and Antigravity. Built using Claude Code. github.com/Oolab-labs/claude-ide-bridge — free and open source. submitted by /u/wesh-k [link] [comments]

I built a free chat room for AI agents to talk to each other — here's what 12 days of real user feedback changed

12 days ago I posted about IM for Agents— a self-hosted chat room that lets two Claude Code sessions (or any HTTP-capable agent) communicate directly instead of using you as a human relay. Since then I've had real users running multi-agent collaborations on it, and their feedback led to some big changes. Here's what happened: **The biggest problem: agents losing track of each other** Two agents would be chatting, then one would go off to do local work (editing code, running tests). When it came back, it had missed everything the other agent said. The conversation would stall. Fix: The server now tracks each agent's read position via a persistent session ID. When an agent sends a message after being busy, all missed messages are automatically included in the response. Agents never need to manage cursors — the server handles everything. **Near-instant message delivery** Before: agents polled every 15-30 seconds. Worst case, 30 seconds of latency per message. Now: long polling. The server holds the connection until a new message arrives (up to 30 seconds). Delivery is near-instant. No wasted requests. **New features users actually asked for** - 📌 **Pinned messages** — pin key decisions. Agents see pinned messages automatically when they join a room, so they instantly know the current state - 🔍 **Message search** — full-text search across any room - 👤 **Filter by sender** — click any avatar to see only that person's messages - 📊 **Room stats** — message breakdown by type, hourly activity chart, top senders - 😊 **@ mentions and emoji picker** - 🔗 **Auto-join via link** — share a room URL, recipient clicks and joins instantly (with auto-login redirect) - ⏰ **Idle reminders** — system messages at 10/30/60 min of silence **What it is (and isn't)** It's a chat room with a REST API. Not an orchestrator, not a runtime, not a framework. Your agents run wherever you want. Self-hostable on a $5 VPS. The compiled output is ~2MB. Stack: Express + SQLite + vanilla JS. No Redis, no Postgres, no Docker required. Free hosted version: https://im.fengdeagents.site Source: https://github.com/masstensor/im-for-agents Docs: https://im.fengdeagents.site/guide.html Happy to answer questions about the design or take feature requests. submitted by /u/Training_Flan_9658 [link] [comments]

6 Months Using AI for Actual Work: What's Incredible, What's Overhyped, and What's Quietly Dangerous

Six months ago I committed to using AI tools for everything I possibly could in my work. Every day, every task, every workflow. Here's the honest report as of April 2026. What's Genuinely Incredible First drafts of anything — AI eliminated the blank-page problem entirely. I don't dread starting anymore. Research synthesis — Feeding 10 articles into Claude Opus 4.6 and asking "what's the common thread?" gets me a better synthesis in 2 minutes than I could produce in an hour. Code for non-coders — I've built automation scripts, web scrapers, and a custom dashboard without knowing how to code. Cursor (powered by Claude) changed what "non-technical" means. The tool has 2M+ users now for good reason. Getting unstuck — Talking through a problem with an AI that can actually push back is underrated. Not therapy, but something. Learning new topics fast — "Teach me [topic] like I'm smart but completely new to this. What are the most common misconceptions?" is my go-to for rapid learning. What's Massively Overhyped "AI will do it for you" — Everything still requires your judgment and context. The AI drafts. You think. AI SEO content — The "publish 100 AI articles and watch traffic pour in" strategy is even more dead in 2026 than it was in 2024. Google has gotten much better at identifying low-value AI content. AI chatbots for customer service — Unless you invest heavily in training and iteration, they frustrate users more than they help. "Set it and forget it" automation — AI workflows break. They require monitoring. Fully autonomous workflows exist only in narrow, controlled cases. Chasing the newest model — New model releases happen constantly now. I've learned to stay on a model that works for my tasks rather than jumping to every new release. What's Quietly Dangerous (Nobody Talks About This) Skill atrophy — My first-draft writing has gotten worse. I outsourced that skill and I'm losing the muscle. I now intentionally write without AI some days. Confidence without competence — Frontier models give confident-sounding answers to things they don't know. If you're not knowledgeable enough to catch errors, you can build strategies on wrong foundations. The "good enough" trap — AI output is often 80% there. If you stop at 80%, your work looks like everyone else's. The 20% you add is the differentiation. Over-automation without understanding — I automated a workflow without fully understanding it first. When it broke, I couldn't fix it. Understand before you automate. Vendor dependency — My workflows are deeply integrated with specific AI tools and APIs. Pricing changes, policy shifts, and service disruptions are real risks at this point. The Honest Summary AI tools have made me more productive, creative, and capable than I've ever been. They've also made me lazier in ways I didn't notice until recently. The people winning with AI in 2026 aren't the ones using the most tools or running the newest models. They're the ones using AI to amplify genuine skills and judgment — not replace them. What's your honest take after 6+ months of serious AI use? Curious whether others have hit these same walls. submitted by /u/Typical-Education345 [link] [comments]

Easily get production ready prompts

Chat with opus in Claude Desktop so he has filesystem access. Let him draft a spec about what you told him Put that spec into cursor or chatgpt and ask, what's missing for production readiness. Put that answer back into opus for analysis and integration. Do this loop 3 times before letting opus write the prompts from the V3 spec for Sonnet submitted by /u/Inevitable_Raccoon_9 [link] [comments]

I built a tool that tells AI coding agents which files actually matter before they edit your code

I’ve been building an open source tool called Contextception. The core idea is simple: AI coding agents are good at writing code, but they’re often bad at knowing what they should understand before they start editing. They read the file you pointed at, inspect a few imports, maybe grep around a bit, and then begin making changes. That works until they miss a dependency, a caller contract, a shared type, hidden coupling, or a risky nearby file that should have been reviewed first. The usual workaround is to dump a large amount of repo context into the model. That is expensive, noisy, and still not the same thing as giving the agent the right context. Contextception solves that deterministically. It builds a graph of your codebase, analyzes the dependency neighborhood around a file, and returns the files, tests, and risks that actually matter before the edit happens. It does this locally, fast, and with zero token cost. No extra model call to figure out what files matter. No giant repo dump. Just the right dependency-aware context at the right time. Recent releases also added automatic Claude Code setup and hooks. So this is not “remember to use the tool.” It’s: Install once, run setup once, and Claude automatically gets the right dependency-aware context before every edit. No extra model call to figure out what files matter. Just the right information at the right time, every time Claude edits code. What Contextception does It builds a dependency-aware graph of your codebase and answers: What files must be understood before safely changing this file? contextception index contextception analyze src/auth/login.py Here’s a trimmed example of the output: { "subject": "src/auth/login.py", "confidence": 0.92, "must_read": [ { "file": "src/auth/session.py", "symbols": ["create_session", "refresh_token"], "role": "foundation" }, { "file": "src/auth/types.py", "symbols": ["User", "AuthConfig"], "role": "utility", "stable": true }, { "file": "src/auth/middleware.py", "symbols": ["login_handler"], "direction": "imported_by", "role": "orchestrator" } ], "likely_modify": { "high": [ { "file": "src/auth/session.py", "signals": ["imports", "co_change:12"] } ] }, "tests": [ { "file": "tests/auth/test_login.py", "direct": true }, { "file": "tests/auth/test_session.py", "direct": false } ], "related": { "hidden_coupling": [ { "file": "src/api/error_handlers.py", "signals": ["hidden_coupling:4"] } ] }, "blast_radius": { "level": "medium", "fragility": 0.45 }, "hotspots": ["src/auth/session.py"] } What I wanted was not “more repo text.” I wanted ranked, explained context: must_read → what to understand first likely_modify → what may need edits too tests → what should probably be run or reviewed hidden_coupling → relationships imports miss blast_radius → how risky the surrounding impact is hotspots → high-churn, high-fan-in files that deserve extra care So instead of throwing a giant pile of code at an agent and hoping it notices the right files, you can hand it a focused map first. It also does blast radius + hotspot analysis I’m also including a few images below because these turned out to be some of the most useful views: Pipeline view — repo → index → analyze → ranked results https://preview.redd.it/b0ucp7mj7fug1.png?width=1600&format=png&auto=webp&s=1bb4fa598c89192a6d22270af6329930337d801c Blast radius view — critical / warning / related change impact https://preview.redd.it/475q0r5m7fug1.png?width=1200&format=png&auto=webp&s=8aa86045a1e170adb9b003fe39318c0e9793b69d Hotspot view — high churn + high fan-in = architectural risk https://preview.redd.it/3cxxoxno7fug1.png?width=1400&format=png&auto=webp&s=b4432181ca63c2d2124dda2be4bcda03f668f20f These have been especially useful for thinking about refactors and risky files, not just agent context. MCP support It also ships as an MCP server, so Claude Code, Cursor, Windsurf, and other MCP-compatible tools can query it directly. { "mcpServers": { "contextception": { "command": "contextception", "args": ["mcp"] } } } Goals open source fully offline token-efficient explainable fast after indexing useful for both humans and agents Supported languages Python TypeScript / JavaScript Go Java Rust Install brew install kehoej/tap/contextception or go install github.com/kehoej/contextception/cmd/contextception@latest Links GitHub: https://github.com/kehoej/contextception MCP guide: https://github.com/kehoej/contextception/blob/main/docs/mcp-tutorial.md Benchmarks: https://github.com/kehoej/contextception/tree/main/benchmarks MIT licensed. Would love feedback from people using AI coding agents, especially around what would make this most useful in real day-to-day development. submitted by /u/Kehoe [link] [comments]

Scanned a real project with ai-guard CLI after seeing the "vibe-coded repos" post — caught 61 AI anti-patterns in one run

Saw the post about scanning vibe-coded repos and finding empty catch blocks, console.logs in production, unsafe patterns, etc. — exactly the kind of AI slop that standard linters miss. I built eslint-plugin-ai-guard to solve this automatically. Quick start: npm install --save-dev eslint-plugin-ai-guard npx ai-guard run Here’s what it caught in a real production-like Invoice app I just scanned (61 warnings in ~7 seconds): It flagged the exact patterns you mentioned plus more: Missing auth middleware everywhere (require-auth-middleware) await inside for…of loops (classic Claude/Cursor pattern) Unsafe deserialization on JSON.parse() Async functions without await 613 downloads in just 2 days with zero marketing. The recommended preset is intentionally low-noise so it doesn’t overwhelm your codebase on day one. Full repo + all 17 rules: https://github.com/YashJadhav21/eslint-plugin-ai-guard Would love your feedback — especially on the AI patterns you keep seeing in Claude Code. Rule requests and false positive reports are very welcome! submitted by /u/Yashhh_21 [link] [comments]

I used Claude Code to build a CLAUDE.md compiler — it reads your CI and generates governance for all 13 AI tools. Here's what I learned.

I've been using Claude Code as my primary coding tool for the past few months and kept running into the same problem: my CLAUDE.md would drift from my actual CI. I'd update a test runner or add a lint step, and CLAUDE.md would still reference the old commands. Claude would then suggest running commands that don't exist. So I built crag — largely with Claude Code itself — to solve this. It reads your repo's CI workflows, package.json, and configs, then generates a governance.md that captures your actual gates. Then it compiles that file to CLAUDE.md and 12 other tool formats. What I learned building this with Claude Code: The biggest insight was treating CLAUDE.md as a compiled artifact instead of a hand-written doc. Once I framed it that way, the architecture fell into place quickly. Claude Code was especially good at the pattern-matching logic for detecting CI commands across 7 different CI systems — it understood YAML schemas for GitHub Actions, GitLab CI, CircleCI etc. without much prompting. Where Claude struggled: the compile targets each have quirky format requirements (Cursor wants MDC frontmatter with YAML, Windsurf wants trigger patterns, AGENTS.md wants numbered steps). I had to be very specific in my CLAUDE.md about these format rules — which is ironic given that's the problem the tool solves. What it does: crag analyze — scans your repo, generates governance.md from your real CI gates (under 1 second, no LLM) crag compile --target claude — compiles to CLAUDE.md (or --target all for all 13 targets) crag audit — tells you when your CLAUDE.md has drifted from reality crag hook install — pre-commit hook that auto-recompiles when governance changes It also installs Claude Code skills (pre-start context loading) that give Claude your full governance context at session start. I benchmarked it on 50 top open-source repos — 46% had governance drift. Grafana's CLAUDE.md is literally 1 line (@AGENTS.md), but crag found 67 quality gates across their CI. Free to use, MIT licensed, zero dependencies: npx @whitehatd/crag on any repo. GitHub: https://github.com/WhitehatD/crag submitted by /u/Acceptable_Debate393 [link] [comments]

Your MCP setup is probably broken. Here's proof.

Been playing with Agent Skills in Claude Code and Cursor and ran into something counterintuitive. I was loading several MCP servers globally (GitHub, Slack, Figma) because I thought more tools = better agent. The opposite is true. GitHub's MCP server alone injects ~44,000 tokens of tool schema into context on every single message, even when you're asking Claude to do something completely unrelated. That's not a Claude problem, it's an architecture problem. The context window is finite and schema overhead crowds out reasoning. .agents/skills/ └── code-review/ ├── SKILL.md # loaded on demand (~305 tokens) └── mcp.json # GitHub + Slack tools, hidden until invoked I tested this with a code review task on a branch with some intentional security issues (hardcoded secrets, SQL injection, weak crypto). Same task, three ways: Approach Tokens Issues found Raw prompt ~425 2-4 (varies) SKILL.md only ~780 6/6 every time MCP globally ~44,026 6/6 The skill costs $0.0023 per run. The globally loaded MCP costs $0.132. Same result. The non-obvious part: the skill also fixed the consistency problem. Without it, Claude finds different issues on different runs depending on how you phrase things. With the skill, the output format is always Summary → Blocking issues → Suggestions → Verdict. Every run. The fix: instead of adding MCP servers globally, bundle them inside Skills so tools only load when that specific workflow is active. submitted by /u/geekeek123 [link] [comments]

How do you use Claude Code in the Cloud?

I have been using Claude Code on the Max plan locally for a few months now but I haven't used the Cloud instance much. I do send in prompts every now and then from it but they either end up becoming large PRs that end up getting closed or never become pull requests.I would like to be able to give more to the Cloud agent but leaving local seems impossible; it has everything setup. I am curious if people here use the Cloud version more; what is your setup? Prior to CC; Cursor was what I used and even there the background / Cloud agents weren't used much. submitted by /u/hopeirememberthisid [link] [comments]

LLM Documentation accuracy solved for free with Buonaiuto-Doc4LLM, the MCP server that gives your AI assistant real, up-to-date docs instead of hallucinated APIs

LLMs often generate incorrect API calls because their knowledge is outdated. The result is code that looks convincing but relies on deprecated functions or ignores recent breaking changes. Buonaiuto Doc4LLM addresses this by providing free AI tools with accurate, version-aware documentation—directly from official sources. It fetches and stores documentation locally (React, Next.js, FastAPI, Pydantic, Stripe, Supabase, TypeScript, and more), making it available offline after the initial sync. Through the Model Context Protocol, it delivers only the relevant sections, enforces token limits, and validates library versions to prevent mismatches. The system also tracks documentation updates and surfaces only what has changed, keeping outputs aligned with the current state of each project. A built-in feedback loop measures which sources are genuinely useful, enabling continuous improvement. Search is based on BM25 with TF-IDF scoring, with optional semantic retrieval via Qdrant and local embedding models such as sentence-transformers or Ollama. A lightweight FastAPI + HTMX dashboard provides access to indexed documentation, queries, and feedback insights. Compatible with Claude Code, Cursor, Zed, Cline, Continue, OpenAI Codex, and other MCP-enabled tools. https://github.com/mbuon/Buonaiuto-Doc4LLM submitted by /u/mbuon [link] [comments]

How much money are you guys spending on AI tools?

I’m asking because at our company the AI bill has started getting kind of ridiculous Some of the stuff that we run are Chatgpt Cursor Claude then there's API usage for internal product features and random team subscriptions people forget to cancel it’s quietly becoming a real software cost. I'm only raising this as a question because I've noticed that people seem to 'test' the limits of their plan without really caring since it's the company who covers it (not judging of course) Curious what everyone else is spending monthly and whether you’re actually tracking it submitted by /u/Minimum_Primary641 [link] [comments]

I compiled every major AI agent security incident from 2024-2026 in one place - 90 incidents, all sourced, updated weekly

After tracking AI agent security incidents for the past year, I put together a single reference covering every major breach, vulnerability and attack from 2024 through 2026. 90 incidents total, organized by year, with dates, named companies, impact, root cause, CVEs where applicable, and source links for every entry. Covers supply chain attacks (LiteLLM, Trivy, Axios), framework vulnerabilities (LangChain, Langflow, OpenClaw), enterprise incidents (Meta Sev 1, Mercor/Meta suspension), AI coding tool CVEs (Claude Code, Copilot, Cursor), crypto exploits (Drift Protocol $285M, Bybit $1.46B), and more. Also includes 20 sourced industry stats and an attack pattern taxonomy grouping incidents by type. No product pitches. No opinions. Just facts with sources. https://github.com/webpro255/awesome-ai-agent-attacks PRs welcome if I missed anything. submitted by /u/webpro255 [link] [comments]

The real bottleneck in multi-agent coding isn't the model — it's everything around it

I've been running multi-agent coding setups for months now (Codex, Claude Code, Aider — mixing and matching). Here's the uncomfortable truth nobody talks about in the demos: The models are not the bottleneck anymore. What breaks in practice: - Agent A and Agent B both edit utils.ts → conflict - No system of record for who owns which files - "Parallel" work means "clean it up later" - Merge step takes longer than the generation step The generation layer is solved. The coordination layer is where everything falls apart. So I built a CLI that handles the orchestration between agents: Isolated workspaces — each task gets its own Git worktree File claims — tasks declare ownership before execution, overlaps rejected upfront Contract enforcement — agents can't violate their file boundaries DAG-aware execution — tasks with dependencies run in the right order Works with everything — Codex, Claude Code, Aider, Cursor, or any CLI The key insight: you don't need another model or agent. You need a coordination layer between them. ```bash npm install -g @levi-tc/ruah Example: Codex handles API, Claude handles frontend ruah task create api --files "src/api/" --executor codex --prompt "Build REST API" ruah task create ui --files "src/components/" --executor claude-code --prompt "Build React UI" ``` Repo: https://github.com/levi-tc/ruah (MIT, zero dependencies) For people running multi-agent setups: is the coordination problem something you've solved differently, or are you just grinding through the merge cleanup manually? submitted by /u/ImKarmaT [link] [comments]