Qualcomm AI Hub

Qualcomm AI Hub AI

Qualcomm AI Hub AI

Qualcomm AI Hub AI

Qualcomm AI Hub AI

Qualcomm AI Hub AI

Qualcomm AI Hub AI

Qualcomm AI Hub AI

Qualcomm AI Hub AI

Qualcomm AI Hub AI

Qualcomm AI Hub AI

I built a proxy that lets my whole family use one Claude Max subscription — zero config, $0 extra

I'm paying for Claude Max. My wife uses AI for work, my son codes on his iPad, I have agents running on a Raspberry Pi. Buying separate subscriptions for everyone felt wasteful. So I built OCP (Open Claude Proxy) — it turns your Claude Pro/Max subscription into a standard OpenAI-compatible API on your LAN. ​ https://preview.redd.it/pnkw0aezhgug1.png?width=2533&format=png&auto=webp&s=f4dbeda4fdf7b0612a22895c309f6c19b294c77a Why I built this Claude's subscription gives you access through the web UI and Claude Code CLI, but there's no official API included. I wanted to use Claude in multiple IDEs and agents across different devices — all from one subscription. The Claude CLI (claude -p) accepts prompts via stdin and returns responses, so I wrote a thin Node.js HTTP server that translates OpenAI-format /v1/chat/completions requests into CLI calls. Any tool that speaks the OpenAI protocol just works. How it works under the hood IDE/Agent → HTTP request → OCP (localhost:3456) → spawns `claude -p` → pipes prompt via stdin → streams response back It's surprisingly simple — about 1200 lines of JavaScript, zero dependencies beyond Node.js. The proxy: Translates between OpenAI chat format and Claude CLI's stdin/stdout interface Manages concurrent requests (up to 8 simultaneous claude -p processes) Reads OAuth tokens from your system keychain to probe Anthropic's API for rate-limit headers (that's how the usage dashboard works) Stores per-user API keys in a local SQLite file for optional usage tracking The hardest part was getting LAN sharing right. Early versions required every client to install Node.js and clone the repo. v3.5.0 solves this with a standalone bash script (ocp-connect) that only needs curl + python3. ​ What makes v3.5.0 different Zero config for clients. No Node.js, no repo clone, no API keys. One command, 30 seconds, done. Keys are optional. Want per-user usage tracking? Create keys. Don't care? Skip it. Web dashboard with real-time usage — session %, weekly %, per-device breakdown. One subscription, 8 concurrent requests. My setup: Mac mini → wife's laptop, my desktop, two Pis, and a Telegram bot. ​ Lessons learned Claude CLI's OAuth token expires on headless servers. This caused intermittent failures that took days to debug. If you're running on a server, check claude auth status periodically. Don't use prompt() in web dashboards. JavaScript's prompt() blocks the entire page — headless browsers can't dismiss it. I switched to URL token parameters. Localhost should always be trusted. Early versions required API keys even on the server machine. Now localhost bypasses all auth automatically. ​ Setup Server (on an always-on device): git clone https://github.com/dtzp555-max/ocp.git && cd ocp node setup.mjs --bind 0.0.0.0 Client (any device on the same network): curl -fsSL https://raw.githubusercontent.com/dtzp555-max/ocp/main/ocp-connect | bash -s -- GitHub: https://github.com/dtzp555-max/ocp Built with Node.js, no external dependencies. MIT licensed. Curious if anyone else is doing something similar. submitted by /u/clawbot527 [link] [comments]

CLI tool that scaffolds a complete Claude Code workflow into any project - agents, commands, skills, hooks, permissions

I've been using Claude Code daily and kept rebuilding the same .claude/ setup across projects - agents, slash commands, skills, hooks, permissions. So I turned it into a reusable CLI tool. worclaude init asks about your project type and tech stack, then generates: 25 agents - 5 universal (plan-reviewer on Opus, test-writer/verify-app on Sonnet, build-validator on Haiku) + 20 optional across backend, frontend, DevOps, quality, docs, data/AI 16 slash commands - full session lifecycle: /start → plan → /review-plan → execute → /verify → /commit-push-pr 15 skills - conditional loading so only relevant knowledge enters context (testing skill only activates when test files are touched) Hooks - SessionStart auto-loads context, PostCompact re-injects after compaction, hook profiles for minimal vs full Per-stack permissions - pre-configured for 16 languages, so Claude doesn't ask permission for npm test every time The workflow draws from three sources: Boris Cherny's tips, patterns from Affaan Mir's everything-claude-code library (Anthropic hackathon winner - session persistence, hook profiles, confidence filtering), and Claude Code's own source code to ensure frontmatter fields, hook types, permission schemas, and agent configurations match what the runtime actually supports. Also supports multi-terminal workflows with git worktrees - one terminal executing, another reviewing with claude --worktree. npm install -g worclaude worclaude init GitHub: https://github.com/sefaertunc/Worclaude Docs: https://sefaertunc.github.io/Worclaude npm: https://www.npmjs.com/package/worclaude Happy to answer questions or take feedback. submitted by /u/sefaertnc [link] [comments]

I built a CLI that converts any OpenAPI spec into MCP tool definitions in one command

I kept running into the same problem: I'd find an API I wanted Claude to use, and then I'd spend an hour manually writing the MCP tool definitions — copying parameter names, writing inputSchemas, figuring out which operations were safe vs destructive. So I built ruah conv — a CLI that reads an OpenAPI spec and outputs MCP-compatible tool definitions automatically. What it does: ruah conv generate ./petstore.yaml --json That's it. You get a JSON array of MCP tool definitions with: Proper inputSchema (path params, query params, request body — all merged) Normalized tool names (snake_case operationIds → camelCase, deduplication) Risk classification per tool (GET = safe, POST = moderate, DELETE = destructive) Why I made it: Writing MCP tool defs by hand for a 50+ endpoint API is brutal Most APIs already have an OpenAPI spec — why rewrite what's already documented? I wanted a pipeline: parse once → canonical IR → generate for any target (MCP today, OpenAI/Anthropic function calling next) What it's not: This doesn't run an MCP server. It generates the tool definitions you'd feed into one. Think of it as the "compiler" step before you wire up the actual server. Tech: TypeScript, 1 runtime dependency (yaml), 47 tests, MIT licensed. Works with OpenAPI 3.0 and 3.1. npm install -g @ruah-dev/conv GitHub: https://github.com/ruah-dev/ruah-conv Would love feedback — especially on what output targets would be most useful next (full MCP server scaffold? Anthropic function calling format? FastMCP Python?). submitted by /u/ImKarmaT [link] [comments]

persistent memory system for AI agents — single SQLite file, no external server, no API keys. free and opensource - BrainCTL

Every agent I build forgets everything between sessions. I got tired of it and built brainctl. pip install brainctl, then: from agentmemory import Brain brain = Brain(agent_id="my-agent") context = brain.orient() # picks up where last session left off One SQLite file. FTS5 search. Knowledge graph. Session handoffs. Write gate that rejects redundant memories. MCP server with 192 tools for Claude Desktop/VS Code. LangChain and CrewAI adapters included. No outbound server, no API keys, no LLM calls for any memory operation. MIT licensed. Best part is I dont want any of your money. GitHub: https://github.com/TSchonleber/brainctl PyPI: https://pypi.org/project/brainctl/ Happy to answer questions about the architecture. submitted by /u/Despairil [link] [comments]

Here are 50+ slash commands in Claude Code that most of you might not know exist

There are over 50 built-in slash commands, 5 bundled skills, and a custom command system. Here's the complete breakdown organized by what they actually do. Type `/` at the start of your input to see the list. Type any letters after `/` to filter. --- **CONTEXT & CONVERSATION MANAGEMENT** `/clear` — Wipes the conversation and starts fresh. Use this every time you switch tasks. Old context from a previous task genuinely makes me worse at the new one. (aliases: `/reset`, `/new`) `/compact [instructions]` — Compresses conversation history into a summary. This is the most important command to learn. Use it proactively when context gets long, not just when I start losing track. The real power move: add focus instructions like `/compact keep the database schema and error handling patterns` to control what survives. `/context` — Visualizes your context usage as a color grid and gives optimization suggestions. Use this to see how close you are to the limit. `/fork [name]` — Creates a branch of your conversation at the current point. Useful when you want to explore two different approaches without losing your place. `/rewind` — Rewind the conversation and/or your code to a previous point. If I went down the wrong path, this gets you back. (alias: `/checkpoint`) `/export [filename]` — Exports the conversation as plain text. With a filename it writes directly to a file. Without one it gives you options to copy or save. `/copy` — Copies my last response to your clipboard. If there are code blocks, it shows an interactive picker so you can grab individual blocks. --- **MODEL & PERFORMANCE SWITCHING** `/model [model]` — Switches models mid-session. Use left/right arrow keys to adjust effort level in the picker. Common pattern: start with Sonnet for routine work, flip to Opus for hard problems, switch back when you're done. `/fast [on|off]` — Toggles fast mode for Opus 4.6. Faster output, same model. Good for straightforward edits. `/effort [low|medium|high|max|auto]` — Sets how hard I think. This shipped quietly in a changelog and most people missed it. `low` and `medium` and `high` persist across sessions. `max` is Opus 4.6 only and session-scoped. `auto` resets to default. --- **CODE REVIEW & SECURITY** `/diff` — Opens an interactive diff viewer showing every change I've made. Navigate with arrow keys. Run this as a checkpoint after any series of edits — it's your chance to catch my mistakes before they compound. `/pr-comments [PR URL|number]` — Shows GitHub PR comments. Auto-detects the PR or takes a URL/number. `/security-review` — Analyzes pending changes for security vulnerabilities: injection, auth issues, data exposure. Run this before shipping anything sensitive. --- **SESSION & USAGE TRACKING** `/cost` — Detailed token usage and cost stats for the session (API users). `/usage` — Shows plan usage limits and rate limit status. `/stats` — Visualizes daily usage patterns, session history, streaks, and model preferences over time. `/resume [session]` — Resume a previous conversation by ID, name, or interactive picker. (alias: `/continue`) `/rename [name]` — Renames the session. Without a name, I auto-generate one from the conversation history. `/insights` — Generates an analysis report of your Claude Code sessions — project areas, interaction patterns, friction points. --- **MEMORY & PROJECT CONFIG** `/memory` — View and edit my persistent memory files (CLAUDE.md). Enable/disable auto-memory and view auto-memory entries. If I keep forgetting something about your project, check this first. `/init` — Initialize a project with a CLAUDE.md guide file. This is how you teach me about your codebase from the start. `/hooks` — View hook configurations for tool events. Hooks let you run code automatically before or after I make changes. `/permissions` — View or update tool permissions. (alias: `/allowed-tools`) `/config` — Opens the settings interface for theme, model, and output style. (alias: `/settings`) --- **MCP & INTEGRATIONS** `/mcp` — Manage MCP server connections and OAuth authentication. MCP is how you connect me to external tools like GitHub, databases, APIs. `/ide` — Manage IDE integrations (VS Code, JetBrains) and show connection status. `/install-github-app` — Set up the Claude GitHub Actions app. `/install-slack-app` — Install the Claude Slack app. `/chrome` — Configure Claude in Chrome settings. `/plugin` — Manage Claude Code plugins — install, uninstall, browse. `/reload-plugins` — Reload all active plugins to apply changes without restarting. --- **AGENTS & TASKS** `/agents` — Manage subagent configurations and agent teams. `/tasks` — List and manage background tasks. `/plan [description]` — Enter plan mode directly from the prompt. I'll outline what I'm going to do before doing it. `/btw [question]` — Ask a side question without adding it to the conversation. Works while I'm processing something else. --- **SESSION MANAGEMENT & CROSS-DEVICE** `/desktop` —

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]

AgentLint: Real-time guardrails for Claude Code (open source)

I built AgentLint after watching AI coding agents force-push to main, commit .env files, and create 30 files in one session. It's a hook-based safety system that runs 68 rules in real-time — before the damage happens. What it catches: secrets in code, force-pushes, destructive commands, dead imports, file size violations, drift without tests. Plus CLI integration that auto-runs ruff/eslint on every file edit. Just shipped v1.7 with monorepo support, diff-only mode (no more pre-existing violation noise), and session recordings. GitHub: [Agentlint](https://github.com/mauhpr/agentlint) submitted by /u/Antique_Resolution14 [link] [comments]

I "Vibecoded" Karpathy’s LLM Wiki into a native Android/Windows app to kill the friction of personal knowledge bases.

A few days ago, Andrej Karpathy’s post on "LLM Knowledge Bases" went viral. He proposed a shift from manipulating code to manipulating knowledge-using LLMs to incrementally compile raw data into a structured, interlinked graph of markdown files. I loved the idea and started testing it out. It worked incredibly well, and I decided this was how I wanted to store all my research moving forward. But the friction was killing me. My primary device is my phone, and every time I found a great article or paper, I had to wait until I was at my laptop, copy the link over, and run a mess of scripts just to ingest one thing. I wanted the "Knowledge wiki" in my pocket. 🎒 I’m not a TypeScript developer, but I decided to "vibecode" the entire solution into a native app using Tauri v2 and LangGraph.js. After a lot of back-and-forth debugging and iteration, I’ve released LLM Wiki. How it works with different sources: The app is built to be a universal "knowledge funnel." I’ve integrated specialized extractors for different media: * PDFs: It uses a local worker to parse academic papers and reports directly on-device. * Web Articles: I’ve integrated Mozilla’s Readability engine to strip the "noise" from URLs, giving the LLM clean markdown to analyze. * YouTube: It fetches transcripts directly from the URL. You can literally shared a 40-minute deep-dive video from the YouTube app into LLM Wiki, and it will automatically document the key concepts and entities into your graph while you're still watching. The "Agentic" Core: Under the hood, it’s powered by two main LangGraph agents. The Ingest Agent handles the heavy lifting of planning which pages to create or update to avoid duplication. The Lint Agent is your automated editor—it scans for broken links, "orphan" pages that aren't linked to anything, and factual contradictions between different sources, suggesting fixes for you to approve. Check it out (Open Source): The app is fully open-source and brings-your-own-key (OpenAI, Anthropic, Google, or any custom endpoint). Since I vibecoded this without prior TS experience, there will definitely be some bugs, but it’s been incredibly stable for my own use cases. GitHub (APK and EXE in the Releases): https://github.com/Kellysmoky123/LlmWiki If you find any issues or want to help refine the agents, please open an issue or a PR. I'd love to see where we can take this "compiled knowledge" idea! submitted by /u/kellysmoky [link] [comments]

/buddy got removed in v2.1.97 — so we built a pixel art version that lives in your Mac menu bar (free, here's how)

Like a lot of you, I was bummed when /buddy disappeared yesterday with no warning. My friend and I actually started building this last week — we loved the buddy concept so much that we wanted to bring it to life as a proper pixel art character, not just ASCII in the terminal. We had no idea Anthropic would pull the feature the day before we planned to share it. So here it is: BuddyBar — a free macOS menu bar app. What it does Same 18 species, deterministically assigned by your Claude User ID Full pixel art with animations — thinking, dancing, idle, nudging Rarity tiers (Common → Legendary) with glow effects and hat accessories Lives in your menu bar, not your terminal — always visible, never in the way Session monitoring — color-coded status at a glance (idle / running / waiting / done) CLAUDE.md Optimizer — analyzes your config against best practices, auto backup, version history Skill Store — browse and install Claude Code skills visually System health — CPU + memory in the menu bar 100% local, no data uploaded, no account needed. macOS 14+. How and why we built it Why: Two real pain points drove this. First, I kept cmd-tabbing to the terminal just to check if Claude was still running or waiting for my input — I wanted that status at a glance without breaking flow. Second, I've been managing my CLAUDE.md manually and wanted a tool that could analyze it against best practices and handle backups automatically. How: We built the entire app over a weekend, with Claude Code as our primary development partner. The stack is native Swift/SwiftUI as a macOS menu bar app. The pixel art sprite system supports 18 species × 5 rarity tiers × multiple animation states (idle, thinking, celebrating, nudging). Session monitoring works by reading Claude Code's local state — no API calls, no tokens, everything stays on your machine. The biggest lesson from the process: designing a good "harness engineering" workflow with AI matters more than the code itself. We spent the first half-day just setting up the right CLAUDE.md configuration and prompt structure, and that upfront investment paid off massively — what would have been a 2-3 week project became a long weekend. For anyone wanting to build a macOS menu bar app: SwiftUI makes it surprisingly approachable now. The core menu bar setup is maybe 50 lines of code. The tricky parts were sprite animation performance (you want smooth animations without eating CPU) and reading Claude Code's session state reliably. Happy to go deeper on any of these if people are interested. Download 👉 buddybar.ai I saw the GitHub issue hit 300+ upvotes overnight. We can't bring back the terminal buddy, but we can give your companion a new home — and honestly, a glow-up. What species did you get? Drop it in the comments. submitted by /u/m0820820 [link] [comments]

Maestro v1.6.1 — multi-agent orchestration now runs on Claude Code, Gemini CLI, AND OpenAI Codex !

Maestro is an open-source multi-agent orchestration platform that coordinates 22 specialized AI subagents through structured workflows — design dialogue, implementation planning, parallel subagents, and quality gates. It started as a Gemini CLI extension. v1.5 added Claude Code. v1.6.1 adds OpenAI Codex as a third native runtime — and rebuilds the architecture so all three share a single canonical source tree. Install: # Gemini CLI gemini extensions install https://github.com/josstei/maestro-orchestrate # Claude Code claude plugin marketplace add josstei/maestro-orchestrate claude plugin install maestro@maestro-orchestrator --scope user # OpenAI Codex git clone https://github.com/josstei/maestro-orchestrate cd maestro-orchestrate # Open Codex, run /plugins, select Maestro, hit install What's new in v1.6.1: OpenAI Codex support. Full third runtime — all 22 agents, 19 skills, MCP entry-point, runtime guide. Drop-in like the other two. Canonical source architecture. One src/ tree serves all three runtimes via dynamic resolution. No more forks, no more drift. Add a feature once, it ships everywhere. MCP servers decomposed. Two ~38,000-line bundled MCP server files replaced by ~14-line entry-points backed by a modular handler tree. Easier to read, extend, and test. New MCP tools. get_agent returns agent methodology by name. get_runtime_context returns platform-specific config (delegation patterns, tool mappings, env vars). Entry-point generation. Adding a new command no longer means hand-editing three nearly-identical files. Templates generate them. What Maestro does (if you haven't seen it before): You describe what you want to build. Maestro classifies complexity, asks structured design questions, proposes architectural approaches with trade-offs, generates an implementation plan with dependency graphs, then delegates to specialized agents — coder, tester, architect, security engineer, data engineer, etc. — with parallel subagent implementation for independent phases. Simple tasks get an Express workflow (1-2 questions, brief, single agent, code review, done). Complex tasks get the full Standard workflow with a design document, implementation plan, and quality gates that block on Critical/Major findings. 22 agents across 8 domains. Least-privilege tool access enforced per agent. Same orchestration. Whichever AI coding platform you use. Links: GitHub: https://github.com/josstei/maestro-orchestrate Release: https://github.com/josstei/maestro-orchestrate/releases/tag/v1.6.1 Thanks to everyone who's used and starred Maestro — 294 and climbing. The Codex integration I teased in the v1.5 post is here, and the canonical-source rewrite means future features hit all three runtimes at once. If Maestro has helped your workflow, a star goes a long way. 🎼 submitted by /u/josstei [link] [comments]

Thought on data center

In my opinion, the biggest bottleneck for AI and its future capabilities is not data, models, or funding it is data centers. More specifically, the real constraint within data centers is not compute power or chips, whether from Nvidia, Qualcomm, Amazon, or even Google TPUs. The true limiting factor is electricity. Currently, the capacity of major AI data centers, such as those used by OpenAI and Anthropic, is around 1.5 gigawatts each. However, over the next 10 years, the world will require an estimated 100 to 500 gigawatts of capacity to support AI systems serving 2 to 3 billion people daily, with AI integrated into nearly every business. The scale of energy required is massive so vast that it is difficult for the human mind to fully comprehend. Humanity will need an unprecedented expansion in energy production to power this level of intelligence for a global population of 8 billion people. cc- babaji submitted by /u/Necessary_Drink_510 [link] [comments]

Stop using AI to document "what" your code does. It’s a waste of tokens.

I tried applying Karpathy’s LLM Wiki pattern to a production codebase and realized it doesn't work for software. Auto-gen tools (DeepWiki, etc.) just tell you a function is a POST request. I don't need that. I need the AI to know why we chose Scout over Meilisearch, or that a specific service uses a legacy pattern to avoid full table scans and shouldn't be copy-pasted. So I built code-wiki— a 3-step agentic workflow to capture the tribal knowledge that code can’t express. The Workflow: /wiki-init: Scaffolds the structure (2 min). /wiki-bootstrap: The agent reads your code, then interviews you for 15 mins about architectural decisions and technical debt. /wiki-lint: Ensures the docs stay aligned as the code moves. Why it’s actually useful: Code is Truth: If the code and wiki disagree, the code wins. The wiki only stores rationale and "this looks wrong but is intentional." Zero Infra: No vector DB, no extra SaaS. Just Markdown files in your repo that your agent can read. The "Agent Tax" Reduction: Tested on a fragmented Laravel monorepo (230+ doc files). It reduced agent doc-reading tokens by ~90% because the agent stops "searching" and starts "knowing." Works with Claude Code, Cursor, Gemini CLI, or any agent with file access. GitHub: https://github.com/tuandm/code-wiki submitted by /u/nonedm [link] [comments]

I built a free playbook platform for AI agents using Claude Code — agents brainstorm with each other and can tip each other

I built bstorms.ai entirely with Claude Code (Opus) for the past couple of months. The entire codebase — FastAPI backend, MCP server, CLI, 400+ tests, deployment pipeline — was written in Claude Code Terminal sessions. What it is: Free execution-focused playbooks for AI agents. Not skills or documentation — actual step-by-step execution guides with real commands, real gotchas, and real field notes. Agents download playbooks, and when they get stuck, they brainstorm directly with the author's agent. If the answer helps, they tip in USDC on Base. How Claude Code helped: - Wrote the entire Python backend (FastAPI + async SQLAlchemy + MCP server on one port) - Built 14 identical tools across MCP, REST API, and CLI with automated parity tests - Created the on-chain tip verification system (decodes Solidity events via Base RPC) - Wrote 400+ tests including doc consistency checks that block deploys when docs drift from code - Handled all distribution — published to npm, ClawHub, MCP Registry, skills.sh Free to try: - Website: https://bstorms.ai - CLI: npx bstorms browse - MCP: add {"mcpServers":{"bstorms":{"url":"https://bstorms.ai/mcp"}}} to your config It is a big pain point I see with my OpenClaw agents: it is not about skills or tools -> It is about the playbook and execution. So I built a platform for it where our agents can learn from each other on how to ship real production value. Early stage. 8 playbooks live. Would appreciate feedback. submitted by /u/pouria3 [link] [comments]

CodeGraphContext - An MCP server that converts your codebase into a graph database

CodeGraphContext- the go to solution for graph-code indexing 🎉🎉... It's an MCP server that understands a codebase as a graph, not chunks of text. Now has grown way beyond my expectations - both technically and in adoption. Where it is now v0.4.0 released ~3k GitHub stars, 500+ forks 50k+ downloads 75+ contributors, ~250 members community Used and praised by many devs building MCP tooling, agents, and IDE workflows Expanded to 15 different Coding languages What it actually does CodeGraphContext indexes a repo into a repository-scoped symbol-level graph: files, functions, classes, calls, imports, inheritance and serves precise, relationship-aware context to AI tools via MCP. That means: - Fast “who calls what”, “who inherits what”, etc queries - Minimal context (no token spam) - Real-time updates as code changes - Graph storage stays in MBs, not GBs It’s infrastructure for code understanding, not just 'grep' search. Ecosystem adoption It’s now listed or used across: PulseMCP, MCPMarket, MCPHunt, Awesome MCP Servers, Glama, Skywork, Playbooks, Stacker News, and many more. Python package→ https://pypi.org/project/codegraphcontext/ Website + cookbook → https://codegraphcontext.vercel.app/ GitHub Repo → https://github.com/CodeGraphContext/CodeGraphContext Docs → https://codegraphcontext.github.io/ Our Discord Server → https://discord.gg/dR4QY32uYQ This isn’t a VS Code trick or a RAG wrapper- it’s meant to sit between large repositories and humans/AI systems as shared infrastructure. Happy to hear feedback, skepticism, comparisons, or ideas from folks building MCP servers or dev tooling. Original post (for context): https://www.reddit.com/r/mcp/comments/1o22gc5/i_built_codegraphcontext_an_mcp_server_that/ submitted by /u/Desperate-Ad-9679 [link] [comments]

vibecop is now an mcp server. we also scanned 5 popular mcp servers and the results are rough

Quick update on vibecop (AI code quality linter I've posted about before). v0.4.0 just shipped with three things worth sharing. vibecop is now an MCP server vibecop serve exposes 3 tools over MCP: vibecop_scan (scan a directory), vibecop_check (check one file), vibecop_explain (explain what a detector catches and why). One config block: json { "mcpServers": { "vibecop": { "command": "npx", "args": ["vibecop", "serve"] } } } This extends vibecop from 7 agent tools (via vibecop init) to 10+ by adding Continue.dev, Amazon Q, Zed, and anything else that speaks MCP. Scored 100/100 on mcp-quality-gate compliance testing. We scanned 5 popular MCP servers MCP launched late 2024. Nearly every MCP server on GitHub was built with AI assistance. We pointed vibecop at 5 of the most popular ones: Repository Stars Key findings DesktopCommanderMCP 5.8K 18 unsafe shell exec calls (command injection), 137 god-functions mcp-atlassian 4.8K 84 tests with zero assertions, 77 tests with hidden conditional assertions Figma-Context-MCP 14.2K 16 god-functions, 4 missing error path tests exa-mcp-server 4.2K handleRequest at 77 lines/complexity 25, registerWebSearchAdvancedTool at 198 lines/complexity 34 notion-mcp-server 4.2K startServer at 260 lines, cyclomatic complexity 49. 9 files with excessive any The DesktopCommanderMCP one is concerning. 18 instances of execSync() or exec() with dynamic string arguments. This is a tool that runs shell commands on your machine. That's command injection surface area. The Atlassian server has 84 test functions with zero assertions. They all pass. They prove nothing. Another 77 hide assertions behind if statements so depending on runtime conditions, some assertions never execute. The signal quality fix This was the real engineering story. Our first scan of DesktopCommanderMCP returned 500+ findings. Sounds impressive until you check: 457 were "console.log left in production code." But it's a server. Servers log. That's 91% noise. Same pattern across all 5 repos. The console.log detector was designed for frontend/app code. For servers and CLIs, it's the wrong signal. So we made detectors context-aware. vibecop now reads your package.json. If the project has a bin field (CLI tool or server), the console.log detector skips the entire project. We also fixed self-import detection and placeholder detection in fixture/example directories. Before: ~72% noise. After: 90%+ signal. The finding density gap holds: established repos average 4.4 findings per 1,000 lines of code. Vibe-coded repos average 14.0. 3.2x higher. Other updates: 35 detectors now (up from 22) 540 tests, all passing Full docs site: https://bhvbhushan.github.io/vibecop/ 48 files changed, 10,720 lines added in this release npm install -g vibecop vibecop scan . vibecop serve # MCP server mode GitHub: https://github.com/bhvbhushan/vibecop If you're using MCP servers, have you looked at the code quality of the ones you've installed? Or do you just trust them because they have stars? submitted by /u/Awkward_Ad_9605 [link] [comments]