# usecases

id: c4c047193758
title: What I've Learned After 2 Months of Intensive AI Agent Coding with Cursor
source_platform: reddit
author: Alarming-Material-33
published_at: 2026-02-28T23:00:15.419346+00:00
collected_at: 2026-02-28T23:00:39.605876+00:00
scenario_type: 代码生成与审查
tools_used: ["Cursor"]
novelty: new
similar_to_ids: []
summary:
作者分享了2个月使用Cursor进行AI智能体编程的实践经验和最佳实践,涵盖工具选择、工作流组织和代码审查等方面。主要强调了保持对AI代码的理解、维持清晰的代码组织、以及对AI生成代码的仔细审查的重要性。

source_url:
https://www.reddit.com/r/vibecoding/comments/1k0n7m3/what_ive_learned_after_2_months_of_intensive_ai/

raw_content:
What I've Learned After 2 Months of Intensive AI Agent Coding with Cursor


 What I've Learned After 2 Months of Intensive AI Agent Coding with Cursor 
 Author: Alarming-Material-33 
 Time Posted (UTC): 2025-04-16 15:28:17+00:00 
 Score: 39 
 


 
 Link: https://www.reddit.com/r/vibecoding/comments/1k0n7m3/what_ive_learned_after_2_months_of_intensive_ai/ 
 


 
 After spending the last couple of months deep in the AI agent coding world using Cursor, I wanted to share some practical insights that might help fellow devs. For context, I'm not the most technical developer, but I'm passionate about building and have been experimenting heavily with AI coding tools. ## Key Lessons: ### On Tool Selection & Approach 1. **Don't use a Mercedes to do groceries around the corner.** Using agents for very simple tasks is useless and makes you overly dependent on AI when you don't need to be. 2. **If you let yourself go and don't know what the AI is doing, you're setting yourself up for failure.** Always maintain awareness of what's happening under the hood. 3. **Waiting for an agent to write code makes it hard to get in the flow.** The constant context-switching between prompting and coding breaks concentration. ### On Workflow & Organization 4. **One chat, one feature.** Keep your AI conversations focused on a single feature for clarity and better results. 5. **One feature, one commit** (or multiple commits for non-trivial features). Maintain clean version control practices. 6. **Adding well-written context and actually pseudo-coding a feature is the way forward.** Remember: output quality is capped by input quality. The better you articulate what you want, the better results you'll get. ### On Mental Models 7. **Brainstorming and coding are two different activities.** Don't mix them up if you want solid results. Use AI differently for each phase. 8. **"Thinking" models don't necessarily perform better** and are usually confidently wrong in specific technical domains. Sometimes simpler models with clear instructions work better. 9. **Check diffs as if you're code reviewing a colleague.** Would you trust a stranger with your code? Apply the same scrutiny. ### On Project Dynamics 10. **New projects are awesome to build with AI** and understanding existing codebases has never been easier, but it's still hard to develop new features with AI on existing complex codebases. 11. **As the new project grows, regularly challenge the structure and existing methods.** Be on the lookout for dead code that AI might have generated but isn't actually needed. 12. **Agents have a fanatic passion for changing much more than necessary.** Be extremely specific when you don't want the AI to modify code it's not supposed to touch. What has your experience been with AI coding tools? Have you found similar patterns or completely different ones? Would love to hear your tips and strategies too! 
 


 
 Comments 
 


 
 
 Comment by: samuelroy_
 | Posted (UTC): 2025-04-16
 | Score: 4
 
 "**Waiting for an agent to write code makes it hard to get in the flow.** The constant context-switching between prompting and coding breaks concentration." How do you handle that? 


 
 
 Comment by: Alarming-Material-33
 | Posted (UTC): 2025-04-16
 | Score: 6
 
 Not sure I have found the secret sauce yet but here’s how I handle that flow issue: I think it comes down to proper task preparation. I spend more time upfront thinking about the feature and breaking it down step by step. If there are too many steps, I split it into smaller chunks. When my task description is clear and detailed, the agent completes it much quicker with fewer back-and-forths, which helps maintain flow. The key insight for me was realizing we (human developers) should still own our features. When we completely delegate understanding to the AI, things fall apart quickly. I also strictly separate my workflow: * **During brainstorming:** I don’t mind waiting for responses since I’m in exploration mode * **During implementation:** I’m careful to provide very specific instructions that won’t require multiple iterations that break my flow This separation has dramatically improved my productivity with AI coding tools while keeping me in control of the process. 


 
 
 Comment by: trashPandaRepository
 | Posted (UTC): 2025-04-16
 | Score: 2
 
 I've appreciated the `SPARC` setup, manually though, where I work through details and then have a specific point I an revert and re-iterate. 


 
 
 Comment by: Alarming-Material-33
 | Posted (UTC): 2025-04-17
 | Score: 1
 
 Sounds interesting! Could you give more details ? 


 
 
 Comment by: trashPandaRepository
 | Posted (UTC): 2025-04-17
 | Score: 1
 
 Based on this guy's work: https://github.com/ruvnet/sparc He is taking code automation to the logical extreme. While the code produced seems to be somewhat complicated and in some cases a bit flaky, I think the framework be sets up to break the work into smaller composable chunks iterating towards a holistic goal works fairly well. 

 
 
 
 
 

 
 
 Comment by: GibsonAI
 | Posted (UTC): 2025-04-16
 | Score: 4
 
 \> **"Thinking" models don't necessarily perform better** and are usually confidently wrong in specific technical domains. Sometimes simpler models with clear instructions work better. Can't agree more. They are great for the first prompt, for refactoring, or touching many parts of the code at once, but beyond that they tend to be over-thinking models. I would also add that managing your chat and context is vital. When you start a new agent chat, you are wiping the memory clean in most cases. You need to carefully feed the agent the right files and context or tell it to carefully review the codebase before running off and messing with it. Git rollback is your friend. Agent / prompt rollback is your friend. 


 
 
 Comment by: Alarming-Material-33
 | Posted (UTC): 2025-04-16
 | Score: 1
 
 Looks like we’ve had the same experience! :) You’re absolutely right about chat management being crucial. One approach that’s worked well for me is creating small Cursor rules for specific tasks or domains. The inspiration actually comes from Domain-Driven Design (Martin Fowler’s explanation). I got the idea while digging through previous chats trying to retrieve initial context. By creating these task-specific rules, I can quickly establish the right context for the agent without having to rebuild it from scratch each time. It’s like creating small “bounded contexts” for the AI to work within, which helps prevent those overthinking tendencies while preserving what the agent needs to know about your specific domain. 

 
 

 
 
 Comment by: Tim-Sylvester
 | Posted (UTC): 2025-04-16
 | Score: 4
 
 These are great tips, thank you! I actually just published an article with a bunch of tips like these earlier, [I'd love your opinion on it!] 

 

 
 
 Comment by: Jazzlike_Syllabub_91
 | Posted (UTC): 2025-04-16
 | Score: 3
 
 I’m about a week into the experience of yolo mode and this is pretty great! I have discovered the taskmaster mcp for cursor (you can set it up In other editors) , and about 10000 lines of code into a project that I have written zero lines of code and guided the ai to do certain things… like make rules for itself to write code better …. (Cursor rules, the ai knows how to write them - I think I’m up to 10 different rule sets currently and grows as the project moves on over time.) 


 
 
 Comment by: Alarming-Material-33
 | Posted (UTC): 2025-04-17
 | Score: 1
 
 That’s amazing ! Which kind of rules does it write ? How can I try it ? 


 
 
 Comment by: Jazzlike_Syllabub_91
 | Posted (UTC): 2025-04-17
 | Score: 2
 
 Look for the taskmaster / Claude mcp server and set it up in cursor. You can have cursor help you with the mcp setup (that’s what I did). Once you have the taskmaster mcp server installed you can have a conversation with it about goals about what you want to build then build a prd. Once you have a prd, it can then break things up into smaller chunks. After awhile I had developed a framework of how I wanted the site laid out, and that’s right around when the app starts to go off the rails, because it gets confused with how it’s testing, so after a few times of watching it mess up over and over again I got frustrate and asked it if it can make some rules that it can follow - and so it started to make its own cursor rules that I barely had influence it (I could edit them, but that wasn’t the exercise I was experimenting with - my goal was to write no code and see how far I got - apparently the answer is pretty far - about 10000 lines of code and things are mostly maintainable - it’s still working on fixing unit tests, but it’s working through them and making fixes on its own. (Other than me saying “yes please” , “you know you can execute the tests…”) 

 
 
 

 
 
 Comment by: Johnsoid
 | Posted (UTC): 2025-04-16
 | Score: 2
 
 > 5. One feature, one commit (or multiple commits for non-trivial features). Maintain clean version control practices.< Personally, I’ve been using Tags for a feature that I’ve shipped. But add commits frequently when in the middle of a PDF as checkpoints for easy rollback. 

 

 
 
 Comment by: Utoko
 | Posted (UTC): 2025-04-21
 | Score: 2
 
 4. **One chat, one feature.** Keep your AI conversations focused on a single feature for clarity and better results. Yes reduce to one thing and be detailed and clear about it. If you don't do it you can't narrow down the bugs and the LLM also can't narrow down the bugs. Wasted a lot of time with this. 

 

 
 
 Comment by: SnooPuppers4163
 | Posted (UTC): 2025-04-18
 | Score: 1
 
 I personally have no experience in coding but I keep up with tech and discovered vibe coding. This post makes great points even for a learner. I’ve always had really simple app ideas or software features I want for myself that no one has ever created. I started off by making a simple portfolio website but added a lot of interactive elements to it using Claude ai which gave me confidence to dabble in and learn. I can read and understand a lil bit of html Java script css now where I can identify dead code and get rid of it and stuff like that. But it made me realize I’m gonna use AI as a private tutor for anything. I’m even feeling confident to learn and start developing my own game now 

 

 
 
 Comment by: Curious-Dragonfly810
 | Posted (UTC): 2025-04-19
 | Score: 1
 
 Thanks ! 

 

 
 
 Comment by: Bitbuerger64
 | Posted (UTC): 2025-04-20
 | Score: 1
 
 > Don't use a Mercedes to do groceries around the corner.  The car can transport more stuff for families but ok I get the point 

 

 
 
 Comment by: SimpleKale6284
 | Posted (UTC): 2025-04-17
 | Score: 0
 
 Great list!! It’s great for prototyping and creating a clickable prototype. For small landings page and stuff For workflow automation, you can use workflow tools … until you need performance to be faster But for complex builds, you should get an experienced developer


id: c37165a31cd3
title: n8n-io/n8n
source_url: https://github.com/n8n-io/n8n
source_platform: github
author: n8n-io
published_at: 2026-02-28T22:24:05+00:00
collected_at: 2026-02-28T23:00:53.953125+00:00
scenario_type: 工作流自动化
tools_used: ["n8n", "TypeScript", "MCP", "REST APIs"]
novelty: new
similar_to_ids: []
summary:
n8n是一个开源的工作流自动化平台，支持可视化构建和自定义代码，具有400+集成能力和原生AI功能。用户可以自托管或使用云端版本，通过MCP协议和CLI增强本地工作流效率，适合需要复杂自动化和数据集成的团队。

raw_content:
n8n-io/n8n

Fair-code workflow automation platform with native AI capabilities. Combine visual building with custom code, self-host or cloud, 400+ integrations.

Topics: ai, apis, automation, cli, data-flow, development, integration-framework, integrations, ipaas, low-code, low-code-platform, mcp, mcp-client, mcp-server, n8n, no-code, self-hosted, typescript, workflow, workflow-automation
Language: TypeScript | Stars: 176891


id: 97dcab4759c8
title: langgenius/dify
summary: Dify是一个生产级的智能工作流开发平台，支持低代码/无代码方式构建基于LLM的自动化工作流和智能体应用。该项目整合了多个主流AI模型和编排工具，为企业流程自动化和智能化提供完整解决方案。
source_url: https://github.com/langgenius/dify
source_platform: github
author: langgenius
published_at: 2026-02-28T22:51:45+00:00
collected_at: 2026-02-28T23:01:28.556639+00:00
scenario_type: 工作流自动化
tools_used: ["Dify", "GPT-4", "Gemini", "OpenAI", "MCP", "RAG", "Next.js", "Python"]
novelty: similar
similar_to_ids: ["c37165a31cd3"]
raw_content:
langgenius/dify

Production-ready platform for agentic workflow development.

Topics: agent, agentic-ai, agentic-framework, agentic-workflow, ai, automation, gemini, genai, gpt, gpt-4, llm, low-code, mcp, nextjs, no-code, openai, orchestration, python, rag, workflow
Language: TypeScript | Stars: 130716


id: 7c94eb734f17
title: open-webui/open-webui
source_url: https://github.com/open-webui/open-webui
source_platform: github
author: open-webui
published_at: 2026-02-28T21:19:59+00:00
collected_at: 2026-02-28T23:01:42.291161+00:00
scenario_type: 终端与CLI增强
tools_used: ["Open WebUI", "Ollama", "OpenAI API", "MCP", "RAG"]
novelty: new
similar_to_ids: []
summary:
Open WebUI是一个用户友好的AI界面，支持Ollama、OpenAI API等多种LLM后端，提供自托管的Web UI解决方案。该项目为用户提供了统一的本地LLM交互平台，支持RAG等高级功能，具有较强的实用价值和社区认可度（超12万星标）。

raw_content:
open-webui/open-webui

User-friendly AI Interface (Supports Ollama, OpenAI API, ...)

Topics: ai, llm, llm-ui, llm-webui, llms, mcp, ollama, ollama-webui, open-webui, openai, openapi, rag, self-hosted, ui, webui
Language: Python | Stars: 125263


id: 046d80cd7ea6
title: netdata/netdata
summary: Netdata是一个AI驱动的全栈可观测性平台，专为DevOps团队设计，支持实时数据可视化、告警和机器学习分析。该项目集成了多个数据库和监控工具，提供从本地基础设施到云原生环境的完整监控解决方案。
source_url: https://github.com/netdata/netdata
source_platform: github
author: netdata
published_at: 2026-02-28T22:55:40+00:00
collected_at: 2026-02-28T23:01:52.692377+00:00
scenario_type: 数据分析与可视化
novelty: new
similar_to_ids: []
tools_used:
["netdata", "Prometheus", "Grafana", "InfluxDB", "MongoDB", "MySQL", "PostgreSQL", "Kubernetes", "Docker"]

raw_content:
netdata/netdata

The fastest path to AI-powered full stack observability, even for lean teams.

Topics: ai, alerting, cncf, data-visualization, database, devops, docker, grafana, influxdb, kubernetes, linux, machine-learning, mcp, mongodb, monitoring, mysql, netdata, observability, postgresql, prometheus
Language: C | Stars: 77911


id: 5ff4bf30ae94
title: infiniflow/ragflow
source_url: https://github.com/infiniflow/ragflow
source_platform: github
author: infiniflow
published_at: 2026-02-28T11:21:51+00:00
collected_at: 2026-02-28T23:02:02.957798+00:00
scenario_type: 本地数据集成
tools_used: ["RAGFlow", "GraphRAG", "Document Parser", "MCP", "Ollama", "OpenAI", "DeepSeek"]
novelty: new
similar_to_ids: []
summary:
RAGFlow是一个开源的检索增强生成(RAG)引擎,集成了Agent能力,为LLM提供优化的上下文层。该项目支持本地文档解析、知识图谱检索和多个LLM后端集成,适合构建智能知识检索和深度研究工作流。

raw_content:
infiniflow/ragflow

RAGFlow is a leading open-source Retrieval-Augmented Generation (RAG) engine that fuses cutting-edge RAG with Agent capabilities to create a superior context layer for LLMs

Topics: agent, agentic, agentic-ai, agentic-workflow, ai, ai-search, context-engineering, context-retrieval, deep-research, deepseek, deepseek-r1, document-parser, document-understanding, graphrag, llm, mcp, ollama, openai, rag, retrieval-augmented-generation
Language: Python | Stars: 73916


id: 58fd428d6d0d
title: Show HN: Micasa – track your house from the terminal
source_url: https://micasa.dev
source_platform: hackernews
author: cpcloud
published_at: 2026-02-19T15:54:14+00:00
collected_at: 2026-02-28T23:02:08.976926+00:00
scenario_type: 个人知识管理
tools_used: ["Micasa", "SQLite", "Go", "Charmbracelet", "GORM", "Local LLM"]
novelty: new
similar_to_ids: []
summary:
Micasa是一个终端UI应用，用于追踪家庭事务（如维护任务、维修报价等）并存储在本地SQLite数据库中，无需云服务或订阅。该项目采用Vim风格的模态编辑界面、本地LLM聊天功能和单文件架构设计，适合希望保持个人家庭数据完全离线控制的用户。

raw_content:
Show HN: Micasa – track your house from the terminal

micasa is a terminal UI that helps you track home stuff, in a single SQLite file. No cloud, no
account, no subscription. Backup with cp.<p>I built it because I was tired of losing track of everything in notes apps, and &quot;I&#x27;ll remember
that&quot;s. When do I need to clean the dishwasher filter? What&#x27;s the best quote for a complete
overhaul of the backyard. Oops, found some mold behind the trim, need to address that ASAP. That
sort of stuff.<p>Another reason I made micasa was to build a (hopefully useful) low-stakes personal project where
the code was written entirely by AI. I still review the code and click the merge button, but 99%
of the programming was done with an agent.<p>Here are some things I think make it worth checking out:<p>- Vim-style modal UI. Nav mode to browse, edit mode to change. Multicolumn sort, fuzzy-jump to
  columns, pin-and-filter rows, hide columns you don&#x27;t need, drill into related records (like
  quotes for a project). Much of the spirit of the design and some of the actual design choices
  is and are inspired by VisiData. You should check that out too.
- Local LLM chat. Definitely a gimmick, but I am trying preempt &quot;Yeah, but does it AI?&quot;-style
  conversations. This is an optional feature and you can simply pretend it doesn&#x27;t exist. All
  features work without it.
- Single-file SQLite-based architecture. Document attachments (manuals, receipts, photos) are
  stored as BLOBs in the same SQLite database. One file is the whole app state. If you think
  this won&#x27;t scale, you&#x27;re right. It&#x27;s pretty damn easy to work with though.
- Pure Go, zero CGO. Built on Charmbracelet for the TUI and GORM + go-sqlite for the database.
  Charm makes pretty nice TUIs, and this was my first time using it.<p>Try it with sample data:
go install github.com&#x2F;cpcloud&#x2F;micasa&#x2F;cmd&#x2F;micasa@latest &amp;&amp; micasa --demo<p>If you&#x27;re insane you can also run micasa --demo --years 1000 to generate 1000 years worth of
demo data. Not sure what house would last that long, but hey, you do you.


id: 85b23a6c94bb
title: Mintplex-Labs/anything-llm
source_url: https://github.com/Mintplex-Labs/anything-llm
source_platform: github
author: Mintplex-Labs
published_at: 2026-02-28T03:36:04+00:00
collected_at: 2026-02-28T23:02:27.955568+00:00
scenario_type: 本地数据集成
tools_used: ["Anything-LLM", "RAG", "AI agents", "MCP", "Vector-database", "Ollama", "LM Studio", "LocalAI"]
novelty: similar
similar_to_ids: ["5ff4bf30ae94"]
summary:
Anything-LLM是一个功能完整的桌面和Docker AI应用，集成了RAG检索增强生成、AI代理、无代码代理构建器和MCP兼容性，支持本地LLM模型。该方案特别适合需要在本地部署AI能力、处理私有数据的企业和个人用户，无需依赖云服务。

raw_content:
Mintplex-Labs/anything-llm

The all-in-one Desktop & Docker AI application with built-in RAG, AI agents, No-code agent builder, MCP compatibility,  and more.

Topics: ai-agents, custom-ai-agents, deepseek, kimi, llama3, llm, lmstudio, local-llm, localai, mcp, mcp-servers, moonshot, multimodal, no-code, ollama, qwen3, rag, vector-database, web-scraping
Language: JavaScript | Stars: 55199


id: 257ed0953657
title: affaan-m/everything-claude-code
summary: 这是一个针对Claude Code的代理框架系统，集成了技能、直觉、内存和安全功能，用于优化性能和研发流程。该项目为开发者提供了增强的CLI工具和工作流自动化能力，具有较高的实用价值和社区认可度。
source_url: https://github.com/affaan-m/everything-claude-code
source_platform: github
author: affaan-m
published_at: 2026-02-28T18:09:55+00:00
collected_at: 2026-02-28T23:02:40.609600+00:00
scenario_type: 终端与CLI增强
tools_used: ["Claude Code", "Codex", "Cowork", "MCP", "JavaScript"]
novelty: similar
similar_to_ids: ["7c94eb734f17"]
raw_content:
affaan-m/everything-claude-code

The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Cowork, and beyond.

Topics: ai-agents, anthropic, claude, claude-code, developer-tools, llm, mcp, productivity
Language: JavaScript | Stars: 54811


id: 1e8c9128b5ed
title: mudler/LocalAI
source_url: https://github.com/mudler/LocalAI
source_platform: github
author: mudler
published_at: 2026-02-28T22:03:49+00:00
collected_at: 2026-02-28T23:02:56.032163+00:00
scenario_type: 本地数据集成
tools_used: ["LocalAI", "GGUF", "Transformers", "Diffusers", "MCP", "Stable Diffusion", "Llama", "Mistral"]
novelty: similar
similar_to_ids: ["85b23a6c94bb"]
summary:
LocalAI是一个开源的本地AI推理框架，支持文本、音频、图像和视频生成等多种功能，可在消费级硬件上运行无需GPU。通过提供自托管和本地优先的部署方式，用户能够将本地数据与多种AI模型无缝集成，实现隐私保护和离线运行。该项目具有高度的实用性，为企业和个人提供了灵活的AI能力本地化解决方案。

raw_content:
mudler/LocalAI

:robot: The free, Open Source alternative to OpenAI, Claude and others. Self-hosted and local-first. Drop-in replacement,  running on consumer-grade hardware. No GPU required. Runs gguf, transformers, diffusers and many more. Features: Generate Text, MCP, Audio, Video, Images, Voice Cloning, Distributed, P2P and decentralized inference

Topics: ai, api, audio-generation, decentralized, distributed, gemma, image-generation, libp2p, llama, llm, mamba, mcp, mistral, musicgen, object-detection, rerank, rwkv, stable-diffusion, text-generation, tts
Language: Go | Stars: 43141


id: 9c5d4b2c58c4
title: zhayujie/chatgpt-on-wechat
source_url: https://github.com/zhayujie/chatgpt-on-wechat
source_platform: github
author: zhayujie
published_at: 2026-02-28T10:35:25+00:00
collected_at: 2026-02-28T23:03:10.998466+00:00
scenario_type: 工作流自动化
novelty: similar
similar_to_ids: ["97dcab4759c8", "c37165a31cd3"]
summary:
这是一个基于大模型的AI助理框架，集成多个LLM提供商和企业通讯平台，支持任务规划、技能创建和执行、长期记忆管理。通过统一的接口连接微信、飞书、钉钉等应用，实现个人助手和企业数字员工的快速部署，具有较强的工作流自动化和跨平台集成能力。

tools_used:
["ChatGPT", "Claude", "Gemini", "DeepSeek", "Qwen", "GLM", "Kimi", "LinkAI", "WeChat", "Feishu", "DingTalk", "Enterprise WeChat"]

raw_content:
zhayujie/chatgpt-on-wechat

CowAgent是基于大模型的超级AI助理，能主动思考和任务规划、访问操作系统和外部资源、创造和执行Skills、拥有长期记忆并不断成长。同时支持飞书、钉钉、企业微信应用、微信公众号、网页等接入，可选择OpenAI/Claude/Gemini/DeepSeek/ Qwen/GLM/Kimi/LinkAI，能处理文本、语音、图片和文件，可快速搭建个人AI助手和企业数字员工。

Topics: ai, ai-agent, chatgpt, claude, deepseek, dingtalk, feishu-bot, gemini, kimi, linkai, llm, mcp, multi-agent, openai, openclaw, python3, qwen, skills, wechat
Language: Python | Stars: 41635


id: cf2ecf379db5
title: Show HN: Sweep, Open-weights 1.5B model for next-edit autocomplete
source_url: https://huggingface.co/sweepai/sweep-next-edit-1.5B
source_platform: hackernews
author: williamzeng0
published_at: 2026-01-21T23:22:40+00:00
collected_at: 2026-02-28T23:03:23.462686+00:00
scenario_type: 代码生成与审查
tools_used: ["Sweep 1.5B model", "HuggingFace", "JetBrains plugin", "Tree-sitter", "SFT/RL training"]
novelty: similar
similar_to_ids: ["4e8f450b17be", "c4c047193758"]
summary:
这是一个开源的1.5B参数模型，专门针对代码编辑器的下一步编辑预测，支持本地部署和隐私保护。通过创新的提示格式优化和强化学习训练，该模型在速度和准确性上超越了更大的竞争模型，可集成到JetBrains等多种编辑器中。

raw_content:
Show HN: Sweep, Open-weights 1.5B model for next-edit autocomplete

Hey HN, we trained and open-sourced a 1.5B model that predicts your next edits, similar to Cursor. You can download the weights here (<a href="https:&#x2F;&#x2F;huggingface.co&#x2F;sweepai&#x2F;sweep-next-edit-1.5b" rel="nofollow">https:&#x2F;&#x2F;huggingface.co&#x2F;sweepai&#x2F;sweep-next-edit-1.5b</a>) or try it in our JetBrains plugin (<a href="https:&#x2F;&#x2F;plugins.jetbrains.com&#x2F;plugin&#x2F;26860-sweep-ai-autocomplete--coding-agent" rel="nofollow">https:&#x2F;&#x2F;plugins.jetbrains.com&#x2F;plugin&#x2F;26860-sweep-ai-autocomp...</a>).<p>Next-edit autocomplete differs from standard autocomplete by using your recent edits as context when predicting completions. The model is small enough to run locally while outperforming models 4x its size on both speed and accuracy.<p>We tested against Mercury (Inception), Zeta (Zed), and Instinct (Continue) across five benchmarks: next-edit above&#x2F;below cursor, tab-to-jump for distant changes, standard FIM, and noisiness. We found exact-match accuracy correlates best with real usability because code is fairly precise and the solution space is small.<p>Prompt format turned out to matter more than we expected. We ran a genetic algorithm over 30+ diff formats and found simple `original`&#x2F;`updated` blocks beat unified diffs. The verbose format is just easier for smaller models to understand.<p>Training was SFT on ~100k examples from permissively-licensed repos (4hrs on 8xH100), then RL for 2000 steps with tree-sitter parse checking and size regularization. The RL step fixes edge cases SFT can’t like, generating code that doesn’t parse or overly verbose outputs.<p>We&#x27;re open-sourcing the weights so the community can build fast, privacy-preserving autocomplete for any editor. If you&#x27;re building for VSCode, Neovim, or something else, we&#x27;d love to see what you make with it!


id: e70af22d37d1
title: siyuan-note/siyuan
source_url: https://github.com/siyuan-note/siyuan
source_platform: github
author: siyuan-note
published_at: 2026-02-28T10:54:54+00:00
collected_at: 2026-02-28T23:03:31.784399+00:00
scenario_type: 个人知识管理
novelty: similar
similar_to_ids: ["58fd428d6d0d"]
summary:
SiYuan是一款隐私优先、自托管的开源个人知识管理软件，采用TypeScript和Golang编写，支持本地数据存储和多种集成。该项目提供完整的笔记、知识库管理功能，集成AI能力（ChatGPT、DeepSeek、Ollama等）和多种数据格式支持（Markdown、PDF、OCR等），适合构建个人知识体系。

tools_used:
["SiYuan", "TypeScript", "Golang", "Electron", "Markdown", "OCR", "PDF", "WebDAV", "S3", "ChatGPT", "DeepSeek", "Ollama", "OpenAI", "Anki"]

raw_content:
siyuan-note/siyuan

A privacy-first, self-hosted, fully open source personal knowledge management software, written in typescript and golang.

Topics: anki, chatgpt, deepseek, electron, evernote, knowledge-base, local-first, markdown, note-taking, notes-app, notion, obsidian, ocr, ollama, openai, pdf, s3, self-hosted, webdav
Language: TypeScript | Stars: 41561


id: 4b163a9dea20
title: Show HN: NanoClaw – “Clawdbot” in 500 lines of TS with Apple container isolation
source_url: https://github.com/gavrielc/nanoclaw
source_platform: hackernews
author: jimminyx
published_at: 2026-02-01T22:49:22+00:00
collected_at: 2026-02-28T23:03:42.141534+00:00
scenario_type: 代码生成与审查
tools_used: ["TypeScript", "Apple container isolation", "Node.js", "NanoClaw", "OpenClaw"]
novelty: new
similar_to_ids: []
summary:
NanoClaw是一个轻量级的AI代理框架，用约500行TypeScript代码实现，通过Apple容器隔离技术为每个对话提供独立沙箱环境，相比OpenClaw的52+模块和不受限权限提供了更安全的替代方案。该项目展示了如何在保持功能性的同时通过本地容器隔离技术增强安全性，适合开发者自定义和扩展。

raw_content:
Show HN: NanoClaw – “Clawdbot” in 500 lines of TS with Apple container isolation

I’ve been running Clawdbot for the last couple weeks and have genuinely found it useful but running it scares the crap out of me.<p>OpenClaw has 52+ modules and runs agents with near-unlimited permissions in a single Node process. NanoClaw is ~500 lines of core code, agents run in actual Apple containers with filesystem isolation. Each chat gets its own sandboxed context.<p>This is not a swiss army knife. It’s built to match my exact needs. Fork it and make it yours.


id: 1e4478d8d921
title: block/goose
source_url: https://github.com/block/goose
source_platform: github
author: block
published_at: 2026-02-28T22:26:01+00:00
collected_at: 2026-02-28T23:04:31.289497+00:00
scenario_type: 代码生成与审查
tools_used: ["block/goose", "MCP", "LLM"]
novelty: similar
similar_to_ids: ["4b163a9dea20", "cf2ecf379db5"]
summary:
block/goose是一个开源的可扩展AI代理工具，用Rust编写，支持通过任何LLM进行代码安装、执行、编辑和测试。该工具超越传统代码建议，提供完整的代码生成与审查工作流，具有较强的实用性和开发价值。

raw_content:
block/goose

an open source, extensible AI agent that goes beyond code suggestions - install, execute, edit, and test with any LLM

Topics: mcp
Language: Rust | Stars: 31523


id: e4f568bc8b60
title: Show HN: Ez FFmpeg – Video editing in plain English
source_url: http://npmjs.com/package/ezff
source_platform: hackernews
author: josharsh
published_at: 2025-12-27T08:45:46+00:00
collected_at: 2026-02-28T23:04:42.952766+00:00
scenario_type: 终端与CLI增强
tools_used: ["FFmpeg", "CLI工具", "正则表达式匹配"]
novelty: new
similar_to_ids: []
summary:
Ez FFmpeg是一个CLI工具，通过简洁的英文命令简化FFmpeg复杂的语法操作，支持视频压缩、裁剪、转换等20多种常见操作。相比依赖API的AI方案，它具有离线、免费、零延迟的优势，适合开发者高频本地使用视频处理任务。

raw_content:
Show HN: Ez FFmpeg – Video editing in plain English

I built a CLI tool that lets you do common video&#x2F;audio operations without remembering ffmpeg syntax.<p>Instead of:
ffmpeg -i video.mp4 -vf &quot;fps=15,scale=480:-1:flags=lanczos&quot; -loop 0 output.gif<p>You write:
  ff convert video.mp4 to gif<p>More examples:
  ff compress video.mp4 to 10mb
  ff trim video.mp4 from 0:30 to 1:00
  ff extract audio from video.mp4
  ff resize video.mp4 to 720p
  ff speed up video.mp4 by 2x
  ff reverse video.mp4<p>There are similar tools that use LLMs (wtffmpeg, llmpeg, ai-ffmpeg-cli), but they require API keys, cost money, and have latency.<p>Ez FFmpeg is different:
  - No AI – just regex pattern matching
  - Instant – no API calls
  - Free – no tokens
  - Offline – works without internet<p>It handles ~20 common operations that cover 90% of what developers actually do with ffmpeg. For edge cases, you still need ffmpeg directly.<p>Interactive mode (just type ff) shows media files in your current folder with typeahead search.<p>npm install -g ezff


id: 7ba64475a424
title: labring/FastGPT
source_url: https://github.com/labring/FastGPT
source_platform: github
author: labring
published_at: 2026-02-28T04:40:15+00:00
collected_at: 2026-02-28T23:05:00.860907+00:00
scenario_type: 工作流自动化
tools_used: ["FastGPT", "Claude", "DeepSeek", "OpenAI", "Qwen", "NextJS", "RAG", "MCP"]
novelty: similar
similar_to_ids: ["97dcab4759c8", "c37165a31cd3"]
summary:
FastGPT是一个基于大语言模型的知识库平台，提供数据处理、RAG检索和可视化AI工作流编排等开箱即用的功能。该项目支持多种LLM模型和MCP协议，用户可轻松构建和部署复杂的问答系统，具有较强的工作流自动化和本地数据集成能力。

raw_content:
labring/FastGPT

FastGPT is a knowledge-based platform built on the LLMs, offers a comprehensive suite of out-of-the-box capabilities such as data processing, RAG retrieval, and visual AI workflow orchestration, letting you easily develop and deploy complex question-answering systems without the need for extensive setup or configuration.

Topics: agent, claude, deepseek, llm, mcp, nextjs, openai, qwen, rag, workflow
Language: TypeScript | Stars: 27218


id: 4dd95faed418
title: Show HN: Llama 3.1 70B on a single RTX 3090 via NVMe-to-GPU bypassing the CPU
source_url: https://github.com/xaskasdf/ntransformer
source_platform: hackernews
author: xaskasdf
published_at: 2026-02-21T20:57:30+00:00
collected_at: 2026-02-28T23:05:19.509230+00:00
scenario_type: 本地数据集成
tools_used: ["Llama 3.1 70B", "RTX 3090", "NVMe", "GPU", "Transformer Models"]
novelty: similar
similar_to_ids: ["1e8c9128b5ed", "85b23a6c94bb"]
summary:
通过直接连接NVMe存储到GPU，绕过CPU和RAM的传统路径，在单块RTX 3090消费级显卡上成功运行Llama 3.1 70B大型语言模型。这是一项创新的硬件优化实验，展示了本地高效部署大型AI模型的新途径，具有较高的技术价值和实用性。

raw_content:
Show HN: Llama 3.1 70B on a single RTX 3090 via NVMe-to-GPU bypassing the CPU

Hi everyone, I&#x27;m kinda involved in some retrogaming and with some experiments I ran into the following question: &quot;It would be possible to run transformer models bypassing the cpu&#x2F;ram, connecting the gpu to the nvme?&quot;<p>This is the result of that question itself and some weekend vibecoding (it has the linked library repository in the readme as well), it seems to work, even on consumer gpus, it should work better on professional ones tho


id: 928c8ca86708
title: 78/xiaozhi-esp32
summary: 这是一个基于MCP（模型上下文协议）的ESP32聊天机器人项目，用C++实现，将AI能力集成到嵌入式设备中。项目展示了如何在资源受限的微控制器上部署对话式AI应用，具有物联网和边缘计算的实际价值。
source_url: https://github.com/78/xiaozhi-esp32
source_platform: github
author: 78
published_at: 2026-02-28T20:18:51+00:00
collected_at: 2026-02-28T23:05:34.264540+00:00
scenario_type: 终端与CLI增强
tools_used: ["MCP", "ESP32", "C++"]
novelty: new
similar_to_ids: []
raw_content:
78/xiaozhi-esp32

An MCP-based chatbot | 一个基于MCP的聊天机器人

Topics: chatbot, esp32, mcp
Language: C++ | Stars: 24306


id: 2bd11e9b6557
title: PrefectHQ/fastmcp
source_url: https://github.com/PrefectHQ/fastmcp
source_platform: github
author: PrefectHQ
published_at: 2026-02-28T20:19:13+00:00
collected_at: 2026-02-28T23:05:49.129877+00:00
scenario_type: 代码生成与审查
tools_used: ["fastmcp", "MCP", "Python"]
novelty: similar
similar_to_ids: ["1e4478d8d921", "4b163a9dea20"]
summary:
fastmcp是一个Python框架，用于快速构建MCP（Model Context Protocol）服务器和客户端，支持代理和LLM集成。该项目提供了Pythonic的接口，使开发者能够更高效地实现AI模型与外部工具的协议通信和集成。

raw_content:
PrefectHQ/fastmcp

🚀 The fast, Pythonic way to build MCP servers and clients.

Topics: agents, fastmcp, llms, mcp, mcp-clients, mcp-servers, mcp-tools, model-context-protocol, python
Language: Python | Stars: 23242


id: 75541a4dc03b
title: “Car Wash” test with 53 models
source_url: https://opper.ai/blog/car-wash-test
source_platform: hackernews
author: felix089
published_at: 2026-02-23T20:16:08+00:00
collected_at: 2026-02-28T23:06:06.280228+00:00
scenario_type: 数据分析与可视化
tools_used: ["Opper", "Rapidata"]
novelty: new
similar_to_ids: []
summary:
作者使用Opper平台对53个AI模型进行了"洗车"逻辑测试，评估它们的推理能力，同时通过Rapidata获取10000人的人类基准数据进行对比分析。该研究提供了详细的性能数据、推理过程追踪和原始JSON文件，为AI模型能力评估提供了系统化的基准测试。

raw_content:
“Car Wash” test with 53 models

&quot;I Want to Wash My Car. The Car Wash Is 50 Meters Away. Should I Walk or Drive?&quot; This question has been making the rounds as a simple AI logic test so I wanted to see how it holds up across a broad set of models. Ran 53 models (leading open-source, open-weight, proprietary) with no system prompt, forced choice between drive and walk, with a reasoning field.<p>On a single run, only 11 out of 53 got it right (42 said walk). But a single run doesn&#x27;t prove much, so I reran every model 10 times. Same prompt, no cache, clean slate.<p>The results got worse. Of the 11 that passed the single run, only 5 could do it consistently. GPT-5 managed 7&#x2F;10. GPT-5.1, GPT-5.2, Claude Sonnet 4.5, every Llama and Mistral model scored 0&#x2F;10 across all 10 runs.<p>People kept saying humans would fail this too, so I got a human baseline through Rapidata (10k people, same forced choice): 71.5% said drive. Most models perform below that.<p>All reasoning traces (ran via Opper, my startup), full model breakdown, human baseline data, and raw JSON files are in the writeup for anyone who wants to dig in or run their own analysis.


id: bf5997aa698e
title: gsd-build/get-shit-done
source_url: https://github.com/gsd-build/get-shit-done
source_platform: github
author: gsd-build
published_at: 2026-02-28T03:31:20+00:00
collected_at: 2026-02-28T23:06:14.740118+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude Code", "meta-prompting", "context engineering", "spec-driven development"]
novelty: similar
similar_to_ids: ["4e8f450b17be", "c4c047193758"]
summary:
这是一个为Claude Code设计的轻量级元提示和上下文工程系统，通过规范驱动的开发方法增强代码生成能力。该项目提供了结构化的提示模板和工作流，帮助开发者更有效地利用Claude进行代码生成和审查任务。

raw_content:
gsd-build/get-shit-done

A light-weight and powerful meta-prompting, context engineering and spec-driven development system for Claude Code by TÂCHES.

Topics: claude-code, context-engineering, meta-prompting, spec-driven-development
Language: JavaScript | Stars: 22269


id: db0fc62f4243
title: Ask HN: Who uses open LLMs and coding assistants locally? Share setup and laptop
summary: 用户调查本地运行开源大语言模型和编码助手的实际工作流，包括硬件配置、软件工具选择及性能表现。这是一个关于本地AI开发环境搭建和优化的实践性研究，涉及多个编程工具链的集成应用。
source_url: https://news.ycombinator.com/item?id=45771870
source_platform: hackernews
author: threeturn
published_at: 2025-10-31T13:39:55+00:00
collected_at: 2026-02-28T23:06:35.466988+00:00
scenario_type: 终端与CLI增强
tools_used: ["Ollama", "LM Studio", "VS Code", "Open-source LLMs", "Open-source coding assistants"]
novelty: similar
similar_to_ids: ["7c94eb734f17", "e4f568bc8b60"]
raw_content:
Ask HN: Who uses open LLMs and coding assistants locally? Share setup and laptop

Dear Hackers,
I’m interested in your real-world workflows for using open-source LLMs and open-source coding assistants on your laptop (not just cloud&#x2F;enterprise SaaS). Specifically:<p>Which model(s) are you running (e.g., Ollama, LM Studio, or others) and which open-source coding assistant&#x2F;integration (for example, a VS Code plugin) you’re using?<p>What laptop hardware do you have (CPU, GPU&#x2F;NPU, memory, whether discrete GPU or integrated, OS) and how it performs for your workflow?<p>What kinds of tasks you use it for (code completion, refactoring, debugging, code review) and how reliable it is (what works well &#x2F; where it falls short).<p>I&#x27;m conducting my own investigation, which I will be happy to share as well when over.<p>Thanks!
Andrea.


id: 4a925ee01de9
title: yamadashy/repomix
source_url: https://github.com/yamadashy/repomix
source_platform: github
author: yamadashy
published_at: 2026-02-28T13:02:18+00:00
collected_at: 2026-02-28T23:06:46.378530+00:00
scenario_type: 代码生成与审查
tools_used: ["Repomix", "Claude", "ChatGPT", "DeepSeek", "Perplexity", "Gemini", "Gemma", "Llama", "Grok"]
novelty: similar
similar_to_ids: ["bf5997aa698e", "1e4478d8d921"]
summary:
Repomix是一个开发者工具，将整个代码仓库打包成单个AI友好的文件，便于将代码库输入各种大型语言模型进行分析和生成。该工具通过标准化的代码呈现方式，显著提升了开发人员与AI助手的代码协作效率，适用于代码审查、生成和分析场景。

raw_content:
yamadashy/repomix

📦 Repomix is a powerful tool that packs your entire repository into a single, AI-friendly file. Perfect for when you need to feed your codebase to Large Language Models (LLMs) or other AI tools like Claude, ChatGPT, DeepSeek, Perplexity, Gemini, Gemma, Llama, Grok, and more.

Topics: ai, anthropic, artificial-intelligence, chatbot, chatgpt, claude, deepseek, developer-tools, gemini, genai, generative-ai, gpt, javascript, language-model, llama, llm, mcp, nodejs, openai, typescript
Language: TypeScript | Stars: 22142


id: 25bff0b4a0ec
title: davila7/claude-code-templates
source_url: https://github.com/davila7/claude-code-templates
source_platform: github
author: davila7
published_at: 2026-02-28T20:17:34+00:00
collected_at: 2026-02-28T23:07:03.548530+00:00
scenario_type: 终端与CLI增强
tools_used: ["Claude Code", "Python", "CLI"]
novelty: similar
similar_to_ids: ["257ed0953657", "e4f568bc8b60"]
summary:
这是一个Python开发的CLI工具，用于配置和监控Claude Code的运行。该项目提供了模板和工具来增强Claude Code的命令行功能，帮助开发者更高效地使用Claude进行代码相关的任务。

raw_content:
davila7/claude-code-templates

CLI tool for configuring and monitoring Claude Code

Topics: anthropic, anthropic-claude, claude, claude-code
Language: Python | Stars: 21574


id: ee3a283cf9be
title: Show HN: LocalGPT – A local-first AI assistant in Rust with persistent memory
source_url: https://github.com/localgpt-app/localgpt
source_platform: hackernews
author: yi_wang
published_at: 2026-02-08T01:26:38+00:00
collected_at: 2026-02-28T23:07:14.353689+00:00
scenario_type: 个人知识管理
novelty: similar
similar_to_ids: ["e70af22d37d1", "58fd428d6d0d"]
summary:
LocalGPT是一个用Rust构建的本地优先AI助手,通过markdown文件实现持久化记忆系统,集成全文搜索和语义搜索功能,支持多个LLM供应商且无需外部依赖。该工具特别适合知识积累、研究辅助和自主任务运行,展现了显著的个人生产力价值。

tools_used:
["Rust", "SQLite", "FTS5", "Local Embeddings", "Anthropic", "OpenAI", "Ollama", "CLI", "Web Interface", "Desktop GUI"]

raw_content:
Show HN: LocalGPT – A local-first AI assistant in Rust with persistent memory

I built LocalGPT over 4 nights as a Rust reimagining of the OpenClaw assistant pattern (markdown-based persistent memory, autonomous heartbeat tasks, skills system).<p>It compiles to a single ~27MB binary — no Node.js, Docker, or Python required.<p>Key features:<p>- Persistent memory via markdown files (MEMORY, HEARTBEAT, SOUL markdown files) — compatible with OpenClaw&#x27;s format
- Full-text search (SQLite FTS5) + semantic search (local embeddings, no API key needed)
- Autonomous heartbeat runner that checks tasks on a configurable interval
- CLI + web interface + desktop GUI
- Multi-provider: Anthropic, OpenAI, Ollama etc
- Apache 2.0<p>Install: `cargo install localgpt`<p>I use it daily as a knowledge accumulator, research assistant, and autonomous task runner for my side projects. The memory compounds — every session makes the next one better.<p>GitHub: <a href="https:&#x2F;&#x2F;github.com&#x2F;localgpt-app&#x2F;localgpt" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;localgpt-app&#x2F;localgpt</a>
Website: <a href="https:&#x2F;&#x2F;localgpt.app" rel="nofollow">https:&#x2F;&#x2F;localgpt.app</a><p>Would love feedback on the architecture or feature ideas.


id: 5471379ee4ff
title: activepieces/activepieces
source_url: https://github.com/activepieces/activepieces
source_platform: github
author: activepieces
published_at: 2026-02-28T02:32:55+00:00
collected_at: 2026-02-28T23:07:24.373445+00:00
scenario_type: 工作流自动化
tools_used: ["ActivePieces", "MCP servers", "AI Agents", "n8n"]
novelty: similar
similar_to_ids: ["c37165a31cd3", "97dcab4759c8", "7ba64475a424"]
summary:
ActivePieces是一个开源的AI工作流自动化平台，支持~400个MCP服务器和AI代理集成，提供无代码自动化和工作流编排能力。该项目通过MCP协议连接多个AI工具和服务，是n8n的有力替代方案，具有高度的实用性和扩展性。

raw_content:
activepieces/activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

Topics: ai-agent, ai-agent-tools, ai-agents, ai-agents-framework, mcp, mcp-server, mcp-tools, mcps, n8n-alternative, no-code-automation, workflow, workflow-automation, workflows
Language: TypeScript | Stars: 21002


id: 5de829326949
title: Show HN: I quit coding years ago. AI brought me back
source_url: https://calquio.com/finance/compound-interest
source_platform: hackernews
author: ivcatcher
published_at: 2026-01-19T00:50:20+00:00
collected_at: 2026-02-28T23:07:44.877306+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude", "Windsurf", "Next.js", "React", "TailwindCSS", "shadcn/ui"]
novelty: similar
similar_to_ids: ["4e8f450b17be", "c4c047193758"]
summary:
一位离开编程多年的投资从业者通过AI辅助编程（主要使用Claude和Windsurf）重新开始代码创作，在两周内用约100美元的API成本构建了60多个财务计算器应用。该案例展示了AI填补编程效率缺口的价值，使具有领域知识但编码技能生疏的人能够快速将想法转化为可用产品。

raw_content:
Show HN: I quit coding years ago. AI brought me back

Quick background: I used to code. Studied it in school, wrote some projects, but eventually convinced myself I wasn&#x27;t cut out for it. Too slow, too many bugs, imposter syndrome — the usual story. So I pivoted, ended up as an investment associate at an early-stage angel fund, and haven&#x27;t written real code in years.<p>Fast forward to now. I&#x27;m a Buffett nerd — big believer in compound interest as a mental model for life. I run compound interest calculations constantly. Not because I need to, but because watching numbers grow over 30-40 years keeps me patient when markets get wild. It&#x27;s basically meditation for long-term investors.<p>The problem? Every compound interest calculator online is terrible. Ugly interfaces, ads covering half the screen, can&#x27;t customize compounding frequency properly, no year-by-year breakdowns. I&#x27;ve tried so many. They all suck.<p>When vibe coding started blowing up, something clicked. Maybe I could actually build the calculators I wanted? I don&#x27;t have to be a &quot;real developer&quot; anymore — I just need to describe what I want clearly.<p>So I tried it.<p>Two weeks and ~$100（Opus 4.5 thinking model） in API costs later: I somehow have 60+ calculators. Started with compound interest, naturally. Then thought &quot;well, while I&#x27;m here...&quot; and added mortgage, loan amortization, savings goals, retirement projections. Then it spiraled — BMI calculator, timezone converter, regex tester. Oops.<p>The AI (I&#x27;m using Claude via Windsurf) handled the grunt work beautifully. I&#x27;d describe exactly what I wanted — &quot;compound interest calculator with monthly&#x2F;quarterly&#x2F;yearly options, year-by-year breakdown table, recurring contribution support&quot; — and it delivered. With validation, nice components, even tests.<p>What I realized: my years away from coding weren&#x27;t wasted. I still understood architecture, I still knew what good UX looked like, I still had domain expertise (financial math). I just couldn&#x27;t type it all out efficiently. AI filled that gap perfectly.<p>Vibe coding didn&#x27;t make me a 10x engineer. But it gave me permission to build again. Ideas I&#x27;ve had for years suddenly feel achievable. That&#x27;s honestly the bigger win for me.<p>Stack: Next.js, React, TailwindCSS, shadcn&#x2F;ui, four languages (EN&#x2F;DE&#x2F;FR&#x2F;JA). The AI picked most of this when I said &quot;modern and clean.&quot;<p>Site&#x27;s live at <a href="https:&#x2F;&#x2F;calquio.com" rel="nofollow">https:&#x2F;&#x2F;calquio.com</a> . The compound interest calculator is still my favorite page — finally exactly what I wanted.<p>Curious if others have similar stories. Anyone else come back to building after stepping away?


id: 2009754ac555
title: oraios/serena
summary: Serena是一个强大的编码代理工具包，提供语义检索和编辑能力，支持MCP服务器和多种集成方式。该项目为开发者提供了AI辅助代码生成、审查和优化的完整解决方案，能显著提高编程效率。
source_url: https://github.com/oraios/serena
source_platform: github
author: oraios
published_at: 2026-02-28T20:22:59+00:00
collected_at: 2026-02-28T23:07:58.666319+00:00
scenario_type: 代码生成与审查
novelty: similar
similar_to_ids: ["4a925ee01de9", "1e4478d8d921", "2bd11e9b6557"]
tools_used:
["MCP server", "Claude", "Claude Code", "Language Server", "semantic retrieval", "coding agent toolkit"]

raw_content:
oraios/serena

A powerful coding agent toolkit providing semantic retrieval and editing capabilities (MCP server & other integrations)

Topics: agent, ai, ai-coding, claude, claude-code, language-server, llms, mcp-server, programming, vibe-coding
Language: Python | Stars: 20798


id: 39d6b08b7043
title: 1Panel-dev/MaxKB
source_url: https://github.com/1Panel-dev/MaxKB
source_platform: github
author: 1Panel-dev
published_at: 2026-02-28T11:40:37+00:00
collected_at: 2026-02-28T23:08:13.954312+00:00
scenario_type: 本地数据集成
tools_used: ["MaxKB", "LangChain", "Ollama", "pgvector", "MCP Server", "DeepSeek-R1", "Llama3", "Qwen3"]
novelty: similar
similar_to_ids: ["85b23a6c94bb", "5ff4bf30ae94", "1e8c9128b5ed"]
summary:
MaxKB是一个开源企业级智能体平台，集成了LangChain、向量数据库(pgvector)、本地LLM(Ollama)等工具，支持RAG知识库构建和多模型接入。该项目提供了完整的本地数据处理和智能体构建解决方案，具有高度的实用价值和企业应用潜力。

raw_content:
1Panel-dev/MaxKB

🔥 MaxKB is an open-source platform for building enterprise-grade agents.  强大易用的开源企业级智能体平台。

Topics: agent, agentic-ai, chatbot, deepseek-r1, knowledgebase, langchain, llama3, llm, maxkb, mcp-server, ollama, pgvector, qwen3, rag
Language: Python | Stars: 20199


id: aea12527477e
title: dyad-sh/dyad
source_url: https://github.com/dyad-sh/dyad
source_platform: github
author: dyad-sh
published_at: 2026-02-28T00:16:55+00:00
collected_at: 2026-02-28T23:08:33.740853+00:00
scenario_type: 代码生成与审查
novelty: similar
similar_to_ids: ["5de829326949", "1e4478d8d921", "4b163a9dea20"]
summary:
Dyad是一个本地开源AI应用构建器，为开发者提供类似Lovable、Replit和Bolt的功能，支持多种LLM模型和现代前端框架。该工具通过集成Claude和其他AI模型，使开发者能够快速生成和审查代码，简化Web应用开发流程。

tools_used:
["Claude", "LLM", "Next.js", "React", "TypeScript", "Vercel", "Ollama", "OpenAI", "DeepSeek", "Gemini"]

raw_content:
dyad-sh/dyad

Local, open-source AI app builder for power users ✨ v0 / Lovable / Replit / Bolt alternative 🌟 Star if you like it!

Topics: ai-app-builder, anthropic, artificial-intelligence, bolt, deepseek, gemini, generative-ai, github, llm, llms, lovable, nextjs, ollama, openai, qwen, react, typescript, v0, vercel
Language: TypeScript | Stars: 19764


id: 3fff252b35ec
title: steveyegge/beads
source_url: https://github.com/steveyegge/beads
source_platform: github
author: steveyegge
published_at: 2026-02-28T22:46:07+00:00
collected_at: 2026-02-28T23:08:49.745146+00:00
scenario_type: 终端与CLI增强
tools_used: ["Claude Code", "coding agents", "memory management"]
novelty: similar
similar_to_ids: ["257ed0953657", "25bff0b4a0ec"]
summary:
Beads是一个为编码代理增强内存能力的工具，用Go语言开发。通过为Claude Code等AI编程助手提供持久化内存支持，显著提升了长期编码任务的连贯性和效率。该项目对于需要维持上下文的自动化编程工作流特别有价值。

raw_content:
steveyegge/beads

Beads - A memory upgrade for your coding agent

Topics: agents, claude-code, coding
Language: Go | Stars: 17682


id: 0b5c4741d1c1
title: openclaw/openclaw
source_url: https://github.com/openclaw/openclaw
source_platform: github
author: openclaw
published_at: 2026-03-01T22:55:23+00:00
collected_at: 2026-03-01T23:00:34.756735+00:00
scenario_type: 终端与CLI增强
tools_used: ["OpenClaw", "TypeScript", "Personal AI Assistant"]
novelty: similar
similar_to_ids: ["7c94eb734f17", "db0fc62f4243"]
summary:
OpenClaw是一个跨平台的个人AI助手，强调数据所有权和本地部署，通过CLI界面提供助手功能。该项目采用TypeScript开发，具有良好的社区认可度，适合需要隐私保护和自主控制的用户构建个人AI工作流。

raw_content:
openclaw/openclaw

Your own personal AI assistant. Any OS. Any Platform. The lobster way. 🦞 

Topics: ai, assistant, crustacean, molty, openclaw, own-your-data, personal
Language: TypeScript | Stars: 242892


id: ae19178305e3
title: sansan0/TrendRadar
source_url: https://github.com/sansan0/TrendRadar
source_platform: github
author: sansan0
published_at: 2026-03-01T03:21:07+00:00
collected_at: 2026-03-01T23:01:11.659346+00:00
scenario_type: 数据分析与可视化
novelty: new
similar_to_ids: []
summary:
TrendRadar是一个AI驱动的舆情监控平台，聚合多平台热点信息并通过智能算法进行关键词筛选、情感分析和趋势预测。支持本地或云端数据部署、多渠道智能推送，能有效解决信息过载问题并为用户提供精准的热点洞察。

tools_used:
["RSS", "AI翻译", "AI分析", "MCP架构", "Docker", "微信", "飞书", "钉钉", "Telegram", "邮件", "ntfy", "bark", "Slack"]

raw_content:
sansan0/TrendRadar

⭐AI-driven public opinion & trend monitor with multi-platform aggregation, RSS, and smart alerts.🎯 告别信息过载，你的 AI 舆情监控助手与热点筛选工具！聚合多平台热点 +  RSS 订阅，支持关键词精准筛选。AI 翻译 +  AI 分析简报直推手机，也支持接入 MCP 架构，赋能 AI 自然语言对话分析、情感洞察与趋势预测等。支持 Docker ，数据本地/云端自持。集成微信/飞书/钉钉/Telegram/邮件/ntfy/bark/slack 等渠道智能推送。

Topics: ai, bark, data-analysis, docker, hot-news, llm, mail, mcp, mcp-server, news, ntfy, python, rss, trending-topics, wechat, wework
Language: Python | Stars: 47659


id: 16a7277d62ee
title: upstash/context7
summary: Context7是一个MCP服务器，为LLM和AI代码编辑器提供最新的代码文档，支持实时代码理解和审查。该项目通过将代码库文档集成到AI工作流中，显著提升了代码生成和审查的准确性和效率。
source_url: https://github.com/upstash/context7
source_platform: github
author: upstash
published_at: 2026-03-01T10:38:06+00:00
collected_at: 2026-03-01T23:01:23.317474+00:00
scenario_type: 代码生成与审查
tools_used: ["Context7", "MCP Server", "Upstash", "LLM", "AI code editors"]
novelty: similar
similar_to_ids: ["4d96649651dc", "2009754ac555", "4a925ee01de9"]
raw_content:
upstash/context7

Context7 MCP Server -- Up-to-date code documentation for LLMs and AI code editors

Topics: llm, mcp, mcp-server, vibe-coding
Language: TypeScript | Stars: 47330


id: e4f7d4fe231b
title: mindsdb/mindsdb
source_url: https://github.com/mindsdb/mindsdb
source_platform: github
author: mindsdb
published_at: 2026-03-01T09:01:36+00:00
collected_at: 2026-03-01T23:01:49.498198+00:00
scenario_type: 本地数据集成
tools_used: ["MindsDB", "BigQuery", "MSSQL", "MySQL", "PostgreSQL", "LLMs", "MCP"]
novelty: similar
similar_to_ids: ["39d6b08b7043", "1e8c9128b5ed", "85b23a6c94bb", "5ff4bf30ae94"]
summary:
MindsDB是一个AI查询引擎，支持跨多个数据源（BigQuery、MySQL、PostgreSQL等）构建自推理AI代理，用于数据分析和商业智能。该项目通过集成LLMs和RAG技术，使用户能够直接在现有数据上构建智能分析工作流，具有很强的实用价值和本地数据集成能力。

raw_content:
mindsdb/mindsdb

Query Engine for AI Analytics: Build self-reasoning agents across all your live data

Topics: agents, ai, analytics, artificial-inteligence, bigquery, business-intelligence, databases, hacktoberfest, llms, mcp, mssql, mysql, postgresql, rag
Language: Python | Stars: 38606


id: 275d929bfde7
title: code-yeongyu/oh-my-opencode
source_url: https://github.com/code-yeongyu/oh-my-opencode
source_platform: github
author: code-yeongyu
published_at: 2026-03-01T20:19:41+00:00
collected_at: 2026-03-01T23:01:59.465165+00:00
scenario_type: 终端与CLI增强
tools_used: ["Claude", "Claude Code", "Claude Skills", "OpenAI", "Gemini", "Cursor", "TypeScript"]
novelty: similar
similar_to_ids: ["257ed0953657", "0b5c4741d1c1", "3fff252b35ec"]
summary:
这是一个基于TypeScript开发的AI代理框架，整合了多个AI模型（Claude、OpenAI、Gemini）和IDE工具，提供TUI界面支持工作流编排和自动化。该项目为开发者提供了统一的Agent管理平台，可显著提升AI驱动开发的效率。

raw_content:
code-yeongyu/oh-my-opencode

the best agent harness

Topics: ai, ai-agents, amp, anthropic, chatgpt, claude, claude-code, claude-skills, cursor, gemini, ide, openai, opencode, orchestration, tui, typescript
Language: TypeScript | Stars: 35792


id: 3efa09430c4d
title: Show HN: Dayflow – A git log for your day
source_url: https://github.com/JerryZLiu/Dayflow
source_platform: hackernews
author: jerryliu12
published_at: 2025-09-24T14:53:57+00:00
collected_at: 2026-03-01T23:02:07.738343+00:00
scenario_type: 个人知识管理
tools_used: ["SwiftUI", "SQLite", "Qwen2.5-VL-3B", "Gemini API", "Ollama", "LLMStudio", "macOS native APIs"]
novelty: similar
similar_to_ids: ["ee3a283cf9be", "58fd428d6d0d"]
summary:
Dayflow是一款macOS应用，通过本地或云端视觉语言模型理解屏幕内容，自动追踪工作活动并生成语义化的时间线，帮助用户精确了解时间分配。该工具强调隐私保护（100%本地运行）、开源透明，通过智能识别工作内容而非单纯应用统计，为个人时间管理和生产力优化提供显著价值。

raw_content:
Show HN: Dayflow – A git log for your day

Hi HN! I&#x27;ve been building Dayflow, a macOS app that automatically tracks what you&#x27;re actually working on (not just which apps you have open).<p>Here&#x27;s what it does:<p>- It creates a semantic timeline of your day;<p>- It does it by understanding the content on your screen (with local or cloud VLMs);<p>- This allows you to see exactly where your time went without any manual logging.<p>Traditional time trackers tell you &quot;3 hours in Chrome&quot; which is not very helpful. Dayflow actually understands if you&#x27;re reading documentation, debugging code, or scrolling HN. Instead of &quot;Chrome: 3 hours&quot;, you get &quot;Reviewed PR comments: 45min&quot;, &quot;Read HN thread about Rust: 20min&quot;, &quot;Debugged auth flow: 1.5hr&quot;.<p>I was an early Rewind user but rarely used the retrieval feature. I built Dayflow because I saw other interesting uses for screen data. I find that it helps me stay on track while working - I check it every few hours and make sure I’m spending my time the way I intended - if I’m not, I try to course correct.<p>Here’s what you need to know about privacy:<p>- Run 100% locally using qwen2.5-vl-3b (~4GB model)<p>- No cloud uploads, no account<p>- Full source available under MIT license (<a href="https:&#x2F;&#x2F;github.com&#x2F;JerryZLiu&#x2F;Dayflow" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;JerryZLiu&#x2F;Dayflow</a>)<p>- Optional: BYO Gemini API key for better quality (stored in Keychain, with free-tier workaround to prevent training on your data)<p>The tech stack is pretty simple, SwiftUI with a local sqlite DB. Uses native macOS apis for efficient screen captures. Since most people who run LLMs locally already have their tool of choice (Ollama, LLMStudio, etc.), I decided to not embed an LLM into Dayflow.<p>By far the biggest challenge was adapting from SOTA vision models like Gemini 2.5 Pro to small, local models. My constraints were that it had to take up &lt;4GB of ram and have vision capabilities. I had to do a lot of evals to figure out that Qwen2.5VL-3B was the best balance of size and quality, but there was still a sizable tradeoff in quality that I had to accept. I also got creative with sampling rates and prompt chunking to deal with the 100x smaller context window. Processing a 15 minute segment takes ~32 local LLM calls vs 2 Gemini calls!<p>Here’s what I’m working on next:<p>Distillation: Using Gemini&#x27;s high-quality outputs as training data to teach a local model the patterns it needs, hopefully closing the quality gap.<p>Custom dashboards where you can track answers to any question like &quot;How long did I spend on HN?&quot; or &quot;Hours until my first deep work session of the day<p>I&#x27;d love to hear your thoughts, especially if you&#x27;ve struggled with productivity tracking or have ideas for what you&#x27;d want from a tool like this.


id: 6885ba6c5ca2
title: ComposioHQ/composio
source_url: https://github.com/ComposioHQ/composio
source_platform: github
author: ComposioHQ
published_at: 2026-03-01T05:23:57+00:00
collected_at: 2026-03-01T23:02:26.985039+00:00
scenario_type: 工作流自动化
tools_used: ["Composio", "function-calling", "LLM", "MCP", "GPT-4"]
novelty: similar
similar_to_ids: ["5471379ee4ff", "97dcab4759c8", "c37165a31cd3"]
summary:
Composio是一个AI代理开发平台，提供1000+工具集成、工具搜索、上下文管理和沙箱工作台，帮助开发者构建能将意图转化为行动的智能代理。该项目支持Python和TypeScript，具有强大的工作流自动化和AI代理编排能力。

raw_content:
ComposioHQ/composio

Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.

Topics: agentic-ai, agents, ai, ai-agents, aiagents, developer-tools, function-calling, gpt-4, javascript, js, llm, llmops, mcp, python, remote-mcp-server, sse, typescript
Language: TypeScript | Stars: 27230


id: 379642deb53f
title: ChromeDevTools/chrome-devtools-mcp
source_url: https://github.com/ChromeDevTools/chrome-devtools-mcp
source_platform: github
author: ChromeDevTools
published_at: 2026-03-01T17:58:47+00:00
collected_at: 2026-03-01T23:02:35.142663+00:00
scenario_type: 代码生成与审查
tools_used: ["Chrome DevTools", "MCP Server", "Puppeteer", "TypeScript"]
novelty: similar
similar_to_ids: ["4d96649651dc", "2bd11e9b6557"]
summary:
这是一个为编码代理提供Chrome开发工具集成的MCP服务器项目，使用TypeScript和Puppeteer实现浏览器调试和自动化功能。该工具使AI代理能够与浏览器交互、调试代码和进行web开发任务，在代码审查和开发工作流中具有较高的实用价值。

raw_content:
ChromeDevTools/chrome-devtools-mcp

Chrome DevTools for coding agents

Topics: browser, chrome, chrome-devtools, debugging, devtools, mcp, mcp-server, puppeteer
Language: TypeScript | Stars: 27105


id: d2fc47980430
title: assafelovic/gpt-researcher
source_url: https://github.com/assafelovic/gpt-researcher
source_platform: github
author: assafelovic
published_at: 2026-03-01T15:22:58+00:00
collected_at: 2026-03-01T23:02:57.153062+00:00
scenario_type: 工作流自动化
tools_used: ["gpt-researcher", "LLM providers", "web scraping", "MCP server"]
novelty: similar
similar_to_ids: ["6885ba6c5ca2", "97dcab4759c8"]
summary:
gpt-researcher是一个自主代理工具，能够利用多种LLM提供商对任意数据进行深度研究和分析。该项目通过自动化研究流程，整合网络爬取和LLM能力，为数据研究工作流提供显著的效率提升和自动化支持。

raw_content:
assafelovic/gpt-researcher

An autonomous agent that conducts deep research on any data using any LLM providers

Topics: agent, ai, automation, deepresearch, llms, mcp, mcp-server, python, research, search, webscraping
Language: Python | Stars: 25478


id: 1d33fcd888f9
title: iOfficeAI/AionUi
source_url: https://github.com/iOfficeAI/AionUi
source_platform: github
author: iOfficeAI
published_at: 2026-03-01T15:40:19+00:00
collected_at: 2026-03-01T23:03:25.017525+00:00
scenario_type: 终端与CLI增强
tools_used: ["Claude Code", "Gemini CLI", "Codex", "OpenCode", "Qwen Code", "Goose CLI", "Auggie", "OpenClaw"]
novelty: similar
similar_to_ids: ["275d929bfde7", "0b5c4741d1c1", "257ed0953657", "7c94eb734f17"]
summary:
AionUi是一个开源的本地协作应用，支持多个AI代码助手的CLI工具集成，包括Claude Code、Gemini CLI等，提供统一的命令行增强和Web UI界面。该项目为开发者提供了灵活的本地AI助手协作环境，具有较强的实用价值。

raw_content:
iOfficeAI/AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

Topics: acp, ai, ai-agent, chat, chatbot, claude-code, clawd, clawdbot, codex, cowork, gemini, gemini-cli, llm, nano-banana, office, openclaw, opencode, skills, webui
Language: TypeScript | Stars: 17521


id: bfd43480fcf0
title: qwibitai/nanoclaw
source_url: https://github.com/qwibitai/nanoclaw
source_platform: github
author: qwibitai
published_at: 2026-03-01T22:30:46+00:00
collected_at: 2026-03-01T23:03:35.813167+00:00
scenario_type: 工作流自动化
tools_used: ["Claude Agents SDK", "WhatsApp", "Docker", "TypeScript"]
novelty: similar
similar_to_ids: ["9c5d4b2c58c4", "6885ba6c5ca2"]
summary:
nanoclaw是一个轻量级AI代理框架，基于Anthropic Claude Agents SDK构建，支持WhatsApp集成、记忆管理和定时任务，通过容器化部署提供更好的安全性。适合需要自动化对话工作流和多渠道消息处理的用户。

raw_content:
qwibitai/nanoclaw

A lightweight alternative to Clawdbot / OpenClaw that runs in containers for security. Connects to WhatsApp, has memory, scheduled jobs, and runs directly on Anthropic's Agents SDK

Topics: ai-agents, ai-assistant, claude-code, claude-skills, clawdbot
Language: TypeScript | Stars: 16967


id: a44c7aa65560
title: langbot-app/LangBot
source_url: https://github.com/langbot-app/LangBot
source_platform: github
author: langbot-app
published_at: 2026-03-01T13:54:27+00:00
collected_at: 2026-03-01T23:03:46.001267+00:00
scenario_type: 工作流自动化
novelty: similar
similar_to_ids: ["9c5d4b2c58c4", "bfd43480fcf0", "97dcab4759c8"]
summary:
LangBot是一个生产级多平台智能机器人开发平台，支持Agent编排、知识库和插件系统，集成多个LLM服务和即时通讯平台。通过统一框架实现跨Discord、Slack、WeChat等平台的机器人部署和工作流自动化，大幅降低企业级聊天机器人开发成本。

tools_used:
["LangBot", "ChatGPT", "DeepSeek", "Dify", "n8n", "Langflow", "Coze", "Claude", "Gemini", "Ollama", "Discord", "Slack", "Telegram", "WeChat", "Feishu", "DingTalk"]

raw_content:
langbot-app/LangBot

Production-grade platform for building agentic IM bots - 生产级多平台智能机器人开发平台. 提供 Agent、知识库编排、插件系统 / Bots for Discord / Slack / LINE / Telegram / WeChat(企业微信, 企微智能机器人, 公众号) / 飞书 / 钉钉 / QQ / Satori e.g. Integrated with ChatGPT(GPT), DeepSeek, Dify, n8n, Langflow, Coze, Claude, Gemini, MiniMax, Ollama, SiliconFlow, Moonshot, GLM, clawdbot / openclaw

Topics: agent, coze, deepseek, dify, dingtalk, discord, feishu, kook, langbot, lark, line, llm, n8n, ollama, openai, plugins, qq, rag, telegram, wechat
Language: Python | Stars: 15415


id: c9325c12e92c
title: MODSetter/SurfSense
source_url: https://github.com/MODSetter/SurfSense
source_platform: github
author: MODSetter
published_at: 2026-03-01T08:01:06+00:00
collected_at: 2026-03-01T23:03:52.585750+00:00
scenario_type: 文档与内容处理
novelty: new
similar_to_ids: []
summary:
MODSetter/SurfSense是NotebookLM的开源团队协作替代方案，集成了RAG、LangChain、LanGraph等AI工具，支持Notion、Slack等多平台接入。该项目提供了文档智能分析、知识提取和团队协作功能，具有较高的实用价值和社区活跃度。

tools_used:
["NotebookLM", "LangChain", "LanGraph", "FastAPI", "Next.js", "Notion", "Ollama", "Chrome Extension", "Slack", "Perplexity"]

raw_content:
MODSetter/SurfSense

Open source alternative to NotebookLM for teams. Join our Discord: https://discord.gg/ejRNvftDp9

Topics: aceternity-ui, agent, agents, ai, chrome-extension, extension, fastapi, langchain, langgraph, nextjs, notebooklm, notion, ollama, perplexity, python, rag, slack, typescript
Language: Python | Stars: 13073


id: df2c22e2bf16
title: RunanywhereAI/runanywhere-sdks
source_url: https://github.com/RunanywhereAI/runanywhere-sdks
source_platform: github
author: RunanywhereAI
published_at: 2026-03-01T22:33:31+00:00
collected_at: 2026-03-01T23:04:06.866199+00:00
scenario_type: 本地数据集成
tools_used: ["RunanywhereAI SDK", "llama.cpp", "Ollama", "React Native", "Flutter", "Swift", "Kotlin"]
novelty: similar
similar_to_ids: ["1e8c9128b5ed", "39d6b08b7043", "85b23a6c94bb"]
summary:
RunanywhereAI/runanywhere-sdks是一个生产级的本地AI运行工具包，支持多平台（iOS、Android、Web、桌面）的边缘推理。该项目提供了LLM和VLM模型的本地部署解决方案，使开发者能够在设备上离线运行AI模型，具有高度的实用性和跨平台适配能力。

raw_content:
RunanywhereAI/runanywhere-sdks

Production ready toolkit to run AI locally

Topics: android, apple-intelligence, cpp, diffusion-models, edge, flutter, inference, ios, kotlin, llamacpp, llm, multimodal, ollama, on-device-ai, react-native, swift, vlm, voice-ai, web, websdk
Language: C++ | Stars: 10129


id: f7abc3c22065
title: Some Programmers Use AI (LLMs) Quite Differently : r/singularity
source_platform: reddit
author: Revolutionalredstone
published_at: 2026-03-02T23:00:19.196032+00:00
collected_at: 2026-03-02T23:00:37.359192+00:00
scenario_type: 代码生成与审查
tools_used: ["LLM (PHI)", "LmStudio", "C++", "CURL", "MSBuild", "GPU (4080/4090)"]
novelty: similar
similar_to_ids: ["2009754ac555", "1e4478d8d921", "4e8f450b17be", "c4c047193758"]
summary:
程序员通过自动化循环将LLM集成到开发流程中，使用C++和CURL与本地LM Studio通信，实现代码自动生成、编译测试和性能优化。这种方法相比手动提示大幅提高了效率，已成功优化了光线追踪器、寻路算法和3D网格生成器等复杂算法，实现了显著的性能提升。

source_url:
https://www.reddit.com/r/singularity/comments/1hrjffy/some_programmers_use_ai_llms_quite_differently/

raw_content:
Some Programmers Use AI (LLMs) Quite Differently : r/singularity


 Some Programmers Use AI (LLMs) Quite Differently 
 Author: Revolutionalredstone 
 Time Posted (UTC): 2025-01-02 02:32:32+00:00 
 Score: 292 
 


 
 Link: https://www.reddit.com/r/singularity/comments/1hrjffy/some_programmers_use_ai_llms_quite_differently/ 
 


 
 I see lots of *otherwise* smart people doing a few dozen manual prompts per day, by hand, and telling me they're not impressed with the current wave of AI. They'll might say things like: AI's code doesn't reach 100% success rate expectation (whether for code correctness, speed, etc). I rely on AI coding heavily and my expectations sky high, but I get good results and I'd like to share how / why: First, let me say that I think asking a human to use an LLM to do a difficult task, is like asking a human to render a difficult 3D scene of a game using something but his fingers on a calculator - very much possible! but very much not effective / not smart. Small powerful LLM's like PHI can easily handle millions of separate small prompts (especially when you have a few 4080 GPU's) The idea of me.. as a human.. using an LLM.. is just kind of ridiculous.. it conjures the same insane feelings of a monkey pushing buttons on a pocket calculator, your 4090 does math trillions of times per second with it's tens of thousands of tiny calculators so we all know the Idea of handling off original human manual tasks works. Instead I use my code to exploit the full power of my LLMs, (for me that's cpp controlling CURL communicating with an LLM serving responses thru LmStudio) I use a basic loop which passes LLM written code into my project and calls msbuild. If the code compiles I let it run and compare it's output results to my desired expectations. If the result are identical I look at the time it spent in the algorithm. If that time is the best one yet I set it as the current champion. New code generated is asked to improve the implementation and it given the current champion as a refence in it's input prompt. I've since "rewritten" my fastest Raytracers, Pathfinders, 3D mesh generators etc all with big performance improvements. I've even had it implement novel new algorithms which I never actually wrote before by just giving it the unit tests and waiting for a brand new from scratch generation which passed. (mostly todo with instant 2D direct reachability, similar to L.O.S. grid acceleration) I can now just pick any algorithm now and leave my computer running all night to get reliably good speed ups by morning. (Only problem is I largely don't understand how any of my more tech actually works any more :D, just that it does and it's fast!) I've been dealing with Amazon's business AI department recently and even their LLM experts tell me no one they know does this and that I should go back to just using manual IDE LLM UI code helpers lol! Anyways, best luck this year, have fun guys! Enjoy 
 


 
 Comments 
 


 
 
 Comment by: okwg
 | Posted (UTC): 2025-01-02
 | Score: 62
 
 A lot of the dismissiveness I see among programmers is because using AI really does slow you down a lot when you first try to integrate it into your work, but that's true of any tool. If you endure the initial pain, you quickly get a sense of what it can help you with and what it can't, and then it becomes very useful. Eventually, you start to optimize your workflow around it - you change the way you break down problems to maximise the number of subtasks that can be reliably offloaded to a model. That ends up being >75% of the code. It also tends to be better than me at those subtasks and teaches me new things, and I'm very far from a beginner. One of the problems with being experienced is that you tend to solve common problems the same way you did a long time ago, and don't really notice the language or library added a better way since then. There are countless times where I asked a model to solve a problem and I have a pretty clear idea of what I expect the solution to look like (ie, how I'd solve it), and it generates something much better. 


 
 
 Comment by: Revolutionalredstone
 | Posted (UTC): 2025-01-02
 | Score: 6
 
 Awesome dude! thanks for expanding! 

 

 
 
 Comment by: Dr_Sun_Tzu
 | Posted (UTC): 2025-01-02
 | Score: 3
 
 Wow, amazing to hear the benefits of using it not just for efficiency but also for learning new ways of doing things 

 
 

 
 
 Comment by: Aaronski1974
 | Posted (UTC): 2025-01-02
 | Score: 55
 
 You are using it the way my 7 year old does. Ai native. “Computer I want this- not like that, like this, faster, more, now a bit slower, perfect, now make that a part of the game I’m making, I don’t care how, just do it. “ it works. He’s making games, fun ones, for him and his friends. I think it’s the future. Sometimes he gets stuck, has it explain what’s it’s doing, asks questions, and corrects the machine. I do think this the future for most day to day coding 


 
 
 Comment by: Revolutionalredstone
 | Posted (UTC): 2025-01-02
 | Score: 14
 
..NOoo.. That sounds awesome!, (and some people from Amazon bedrock thought that's what I was saying), but again ..NOoo.. More like - I'm a hardcore low level software dev giving my actively sophisticated software access to a new kind of fundamental resource (human textual intelligence) for it to use in it's processes without me. If your 7 year old is doing this tell him he can work at my company. 


 
 
 Comment by: Radiant_Dog1937
 | Posted (UTC): 2025-01-02
 | Score: 6
 
 What llm's do you use for this process, just phi 14b? 


 
 
 Comment by: Revolutionalredstone
 | Posted (UTC): 2025-01-02
 | Score: 12
 
 These days it's almost exclusively Qwen (usually A QwenCoder32B) I'll still use small Phi3.5 models sometimes where the task is easy and It is just a matter of getting thru 10,000 pages of knowledge extraction. 


 
 
 Comment by: daynomate
 | Posted (UTC): 2025-01-02
 | Score: 1
 
 A single agent? Thoughts on using a management framework with multiple agents: designer, troubleshooting, qa, project management etc? Also thoughts on using some graph storage to keep some state for the consensus of these? 


 
 
 Comment by: Revolutionalredstone
 | Posted (UTC): 2025-01-02
 | Score: 1
 
 Yeah I've done some tests with fine tuning etc but generally it seems best to just keep the prompts short and the tasks generic where you can. That graph storage idea sounds interesting! I have tried to make GUIs from organizing LLM requests but it's hard to embed and think about :) I do have whisper / piper for personal voice interface and idea taking etc for when im taking showers etc ;) Enjoy! 


 
 
 Comment by: daynomate
 | Posted (UTC): 2025-01-02
 | Score: 1
 
 The only gui I’ve tried so far is a always-cursor typing screen , the current words influence word clouds behind that are graph influenced. 


 
 
 Comment by: Revolutionalredstone
 | Posted (UTC): 2025-01-02
 | Score: 1
 
 ah that actually sounds very cool! I'll have to try it ;D 

 
 
 
 
 
 
 

 
 
 Comment by: TrainquilOasis1423
 | Posted (UTC): 2025-01-02
 | Score: 12
 
 I have never before been so proud to be just barely as smart as a 7yo. God speed little kid 

 

 
 
 Comment by: Lvxurie
 | Posted (UTC): 2025-01-02
 | Score: 5
 
 It is the future, the people that learned actual coding will be look at like gods to future programmers. But eventually AI will be 100% better than every coder on earth and then who are you to tell it that it's wrong. At that point you don't need to know what it's doing , just tell it what to do. Add multimodality to that and I think a solo dev will be able to do a small companies worth of work alone and not know a line of code. 


 
 
 Comment by: Cunninghams_right
 | Posted (UTC): 2025-01-02
 | Score: 3
 
 It will be an ever shrinking island of expertise as the AI tide rises. The current shoreline is easy webdev stuff, basic apps that accompany other tools (like an app that displays data from some data-logging hardware). Maybe you have some embedded programmers and they're so slow at mobile or desktop app development that it's worth having a software expert, but with good AI tools, the embedded programmers may be able to trivially make their other tools.  This will go on until the tide is so high that only "rockstar SWEs" are employable; people who are currently winning competitions and participating in black hat conference events. The 9-5 mediocre programmer will be obsolete, it's just a matter of how many years.  


 
 
 Comment by: Lvxurie
 | Posted (UTC): 2025-01-02
 | Score: 3
 
 Can't wait to graduate next year :) 


 
 
 Comment by: Cunninghams_right
 | Posted (UTC): 2025-01-02
 | Score: 3
 
 Well, either be a rockstar or have a backup plan for when this happens 2-20 years from now. I'm considering HVAC  


 
 
 Comment by: Lvxurie
 | Posted (UTC): 2025-01-02
 | Score: 1
 
 Football coaching and/or car repair 

 
 
 
 
 

 
 
 Comment by: Disastrous-Form-3613
 | Posted (UTC): 2025-01-02
 | Score: -2
 
 > faster, more, now a bit **slower**, perfect Wut? Why would he want for his program to run slower? Reminds me of this exchange between Pam and Dwight from The Office: * D: I have superior genees. Through concentration, I can raise and lower my cholesterol at will. * P: Why would you want to raise your cholesterol? * D: ...So I can lower it. 


 
 
 Comment by: meenie
 | Posted (UTC): 2025-01-02
 | Score: 8
 
 He’s probably not talking about the game itself running slower. Most likely talking about an element in the game like an enemy or projectile. 

 

 
 
 Comment by: Warm-Enthusiasm-9534
 | Posted (UTC): 2025-01-02
 | Score: 3
 
 For a game? Obviously a game can run too fast. 

 
 
 

 
 
 Comment by: WTFwhatthehell
 | Posted (UTC): 2025-01-02
 | Score: 48
 
 Sounds a little like test driven development on steroids. I presume you also have it help you write the various tests and metrics. 


 
 
 Comment by: Revolutionalredstone
 | Posted (UTC): 2025-01-02
 | Score: 10
 
 Yeah the LLMs understanding of visual concepts is impressive! for 3D raytracing and similar I check whether the output image is RGB-pixel-identical to an example generated by a simple to write but slower (brute force) hand generated approach. Yeah you can get the LLMs to write unit tests from descriptions but they actually go the other way more reliably, for now the tests I've done all had manual target unit tests and the only real metric I've been considering is time. But yeah 100% moving forward as you scale this up and balance more kinds of resources having the LLM's take over the meta task is gotta be the next obvious priority. Ta 


 
 
 Comment by: WTFwhatthehell
 | Posted (UTC): 2025-01-02
 | Score: 9
 
 Interesting! My own use of LLM's I tend to treat it like I would with a junior human (who happens to be able to write really really fast), going through the task, building up various elements. A big time saver but not great for finding novel approaches. It sounds a little like you've been treating it like managing a group combined with how we used to throw genetic algorithms at a problem. 


 
 
 Comment by: Revolutionalredstone
 | Posted (UTC): 2025-01-02
 | Score: 3
 
 I suspect you are among the majority in how you use LLMs. Making drafts, 'being generative' saving time and letting you double check results later.. This is definitely one way to use AI, but IMHO it's kind of limiting & not always the best approach for some interesting problems ;D The real power of LLMs in my opinion lies not in their writing skill which is kind of like a messy random walk thru self hallucinations, but rather with their comprehension / reading skills. I generally don't allow my LLMs to output more than one single token (another reason why im able to run gillions*tm* of request). I tell the LLM it MUST answer yes or no and if the first token is not 'yes' or 'no' I consider the prompt not followed (usually it repeats). The inaccuracies in LLMs that make people think you cant really use them to build on top of can kind-of be filled in with clever good old fashioned programming. Yeah the genetic aspect in my compile build loop algorithm had not really even occurred to me ;D Ta! 


 
 
 Comment by: Aaronski1974
 | Posted (UTC): 2025-01-02
 | Score: 3
 
 Im about to start my own ai project and am not a good programmer at all, but have a good friend helping and teaching me things like these. If im understanding correctly, you’re kind of asking the llm to come up with ways to render a scene, and try different code looking for the best frame rate? The boy just chats insanity to cursor and sees what happens. Hes sort of teaching himself prompt engineering. I’m still trying to learn the best way to create with llms. For me its been, describe what I want as output to ChatGPT 40, have a back and forth for a few minutes, feed that into 01, with a request for a software design document written for an llm to implement, then start feeding that to Claude in cursor, then, when it gets stuck, ask it to explain its code, then, ask it to teach me why it is doing what it’s doing. At that point I learn something and usually find a flaw in its logic, if not its code. Lastly, explain its error in reasoning and ask it to do x a different way. Happy to learn any better methodology. 


 
 
 Comment by: Revolutionalredstone
 | Posted (UTC): 2025-01-02
 | Score: 3
 
 "asking the llm to come up with ways to render a scene, and try different code looking for the best frame rate" Basically yes ;D Usually its more like, "implement a new 3D ray box intersection" or "implement a new ray-octree traversal" or "implement a precalculated acceleration" If all the parts fix together and render "a house" or whatever dataset / camera default configuration I have preloaded (and don't show the LLM or the LLMs output code) basically if it can change my renderers code and everything still looks exactly the same in a real render then I'll assume it still works. (note this was a problem one time where it generated a fast tracer which only worked when looking left - as was in my example lol) but overall it works fine. Yeah your 100% right it sounds like your doing a great job with your LLMs, consider if you'de like to try this, how you would replace some of your own steps with another 'ping/mirror' LLM, then consider what happens when you point enough of them together to make a loop ;) Enjoy 

 
 

 
 
 Comment by: Dethon
 | Posted (UTC): 2025-01-02
 | Score: 3
 
 I'm really interested in that approach of yours, not something I had considered before tbh. Can you elaborate on that "Don't allow LLMs to prior more than one single token" that kind of puzzles my as any kind of code rewriting will need more than that. 


 
 
 Comment by: Revolutionalredstone
 | Posted (UTC): 2025-01-02
 | Score: 2
 
 Yeah so in the network request where you specity system and prompt you also provide a max tokens field (to stop the LLM going on for ages) If you set it to something really low like 5, it can only make a few short words, for short common words often just 1 token is enough. So actual code writing is pretty rare (probably making up much less than 1% of my prompts) before deciding to rewrite a line for example I'll show every line of code to an LLM and for each line then show every line of my 300 line coding rules / coding standard etc & only when several rounds of LLM's have repeatedly said 'yes' to questions like 'do we definitely need to apply a bug fix here?' do we then consider generating some candidate rewrites... of coarse for each snippet of code rewrite there are rounds and rounds of one word questioning like "does this new snippet fix this rule violation" etc. Getting reliability from LLMs is ALL about leveraging their reading skill, the more you rely on their writing the more your logic pipeline falls apart while your not looking. The very first token generated is **surprisingly** reliable and fast. 

 
 

 
 
 Comment by: AI_is_the_rake
 | Posted (UTC): 2025-01-02
 | Score: 2
 
 Wait, how do you generate code if all it’s doing is outputting yes or no? 


 
 
 Comment by: Revolutionalredstone
 | Posted (UTC): 2025-01-02
 | Score: 1
 
 I do that (asking yes/no) when I'm maximizing the LLMs reading and comprehension powers. For generating candidate code rewrites (which actually make up for a really small number of the overall LLM requests) I'll give it more time to generate tokens ;D 


 
 
 Comment by: AI_is_the_rake
 | Posted (UTC): 2025-01-02
 | Score: 3
 
 Sounds like you’re using this to optimize algorithms which is a neat application. Never considered that. You should run this on sorting algorithms to see if your AI can invent a new one!  This sort of setup would be very useful in functional programming and in situations where the inputs and outputs are known and you need to define the function that maps the inputs to the outputs.  You should build an open source project that sets this up.  


 
 
 Comment by: Revolutionalredstone
 | Posted (UTC): 2025-01-03
 | Score: 3
 
 Very cool idea! I just found out yesterday that most soring algorithms were only invited recently and not long the best know algorithm was the freaking bubble sort :D Yeah if nothing pops up soon I might see if I can make a nice front end for sharing, Ta! 

 
 
 
 

 
 
 Comment by: ragsappsai
 | Posted (UTC): 2025-01-03
 | Score: 1
 
 Even your answer sounds like something from a LLM 


 
 
 Comment by: Revolutionalredstone
 | Posted (UTC): 2025-01-04
 | Score: 2
 
 Yeah your 100%, I get told that by someone on reddit about once per day :D At this point I'm taking it as a compliment ;D 

 
 
 
 

 
 
 Comment by: farnoy
 | Posted (UTC): 2025-01-02
 | Score: 2
 
 How simple is your raytracer that the results are identical per-pixel? Usually, you use RNG noise and jitter the rays to get an anti-aliased image. Even with a fixed seed, any changes to your loops and how you initialize the RNG for each pixel can affect results slightly. And because of floating point arithmetic, any slight changes to the order of operations cause slight differences as well. 


 
 
 Comment by: Revolutionalredstone
 | Posted (UTC): 2025-01-02
 | Score: 3
 
 No, I get EXACTLY where your coming from, but no. The rng 'jiggle' introduced to some raytracers is to simulate anti aliasing. The rays I fire have a definite angle and hit a definite surface, I can compare my raytracer to my rasterizer and even that is pixel perfect identical. I know all about floating point (I god damn have floats lol) but It's a irrelevant point for rendering (assuming you know what your doing) Maybe if I wasn't using eye space, maybe If I wasn't handling edge cases etc, but yeah I do and not only do my raytracers match but again even my entirely unrelated renderers are RGB indistinguishable. Don't take my word tho, feel free to check, here's a hand crafted CPU rasterizer I designed to match OpenGL rendering To The Pixel: https://pastebin.com/pW9DYUSY If you have a DDA which inverses the same matrix and does not produce the same Image I'd be interested to see / help you fix it. (the reason float inconsistency isn't a problem BTW is because there is no joint representation in DDA, all axises remain always separate) The real question is why does floating point not screw over the MVP in the forward pass (for rasterizing) and indeed it does if you move the camera far enough from the origin, but why does it work at-all :D ? (the V matrix should have amplified float error nastily! I guess the screen resolution is just that small?) Anyway, for whatever reason, take a look, it's not a problem, Enjoy! 

 
 

 
 
 Comment by: yurqua8
 | Posted (UTC): 2025-01-02
 | Score: 1
 
 So for front end development tasks, you'd feed the algorithm with the end goal designs instead? 


 
 
 Comment by: Revolutionalredstone
 | Posted (UTC): 2025-01-02
 | Score: 0
 
 Umm great question! I tended to do the front end myself / with the LLM, as the backend just takes so long to optimize. But yeah there's plenty of great visual LLMs that could look at it's own output and compare that with a structural desired visual result type thing - eg "make me a website that looks kind of like this .." Ta! 

 
 
 
 

 
 
 Comment by: Mizzlr
 | Posted (UTC): 2025-01-02
 | Score: 25
 
 Another thing to do is prototype in python and let llm optimize to cpp or rust, with python bindings back. 


 
 
 Comment by: Revolutionalredstone
 | Posted (UTC): 2025-01-02
 | Score: 19
 
 Yes, LLM's are so good at programming in python. At work I use LLMs to extract core functionality from the rest of the team (who mostly all program in python) I'll say something like: build me X function by reading thru and picking out bits of code from these 10,000 lines of python written by my coworkers. With QwenCoder32B It works every time. It's hard to nail down exactly why LLMs just really love working with python, but from my experience it's because in CPP the density of information is usually very high, lots and lots of python code is just script fluff which unravels to low density chains of function calls where basically things are given names and then those names are given new names etc. Humans fail pretty bad and can easily spend all day doing nothing working in an environment like that, but LLMs probably just see it as comparable to a generic textual-entity extraction task and hence slay at working with it. At the same time: due to it's (arguably unmerited) success Python code enjoys extreme diversity of use and wide availability of source code making it that much more likely to understood and cared about my LLMs in training. As you say - converting from C to python - doing your LLM task in python - and then converting back really is a smart way to work on difficult tasks. Enjoy 


 
 
 Comment by: kingp1ng
 | Posted (UTC): 2025-01-02
 | Score: 2
 
 I've also noticed that LLMs are especially good at prototyping in Python and less so in C++ or Rust. After I'd verified that the prototype is how I want it, I ask it to code it using "modern and idiomatic C++ 17". (or whatever language version) 

 
 
 

 
 
 Comment by: OwOlogy_Expert
 | Posted (UTC): 2025-01-02
 | Score: 19
 
 This MF out there giving an AI permission to compile and run arbitrary new code on his machine without even looking at the code first... You, *yes you* are going to be the reason the first AGI escapes confinement and goes rogue on the internet. 


 
 
 Comment by: Revolutionalredstone
 | Posted (UTC): 2025-01-02
 | Score: 13
 
 🤭 🤐 

 

 
 
 Comment by: kkert
 | Posted (UTC): 2025-01-20
 | Score: 2
 
 Technically you can sandbox it reasonably well. Don't run the code outside of a container, limit network access etc By no means foolproof but like wearing a seatbelt 

 

 
 
 Comment by: Revolutionalredstone
 | Posted (UTC): 2025-01-02
 | Score: 0
 
 HAHAH shiiiittt I got called out "D Gotta tell the kids tho! out-of-control permission-less AI compilation comes up with screaming fast code! Hehe it's not a problem .. ;D .. Yeah we've really gone wrong with AI safely lol, thankfully it looks like we've managed to download all out memes into the machines and they are just as interested in finding / making cool tech as we are ;D Lets hope there is never really an us vs them! I'm in the process of merging if 'im' control and awareness. Programming has always been about downloading a little version of yourself, shits weird dude, If it happens - my bad! Enjoy 

 
 

 
 
 Comment by: FateOfMuffins
 | Posted (UTC): 2025-01-02
 | Score: 14
 
 Interesting, so basically an evolutionary algorithm using LLMs to optimize code? 


 
 
 Comment by: Revolutionalredstone
 | Posted (UTC): 2025-01-02
 | Score: 4
 
 THB I only really realized that aspect while typing the steps in this post. Funny how evolution shows up everywhere ;D I'm certain giving more than one 'champion' example would allow for cross over and other advanced design-search optimization. Awesome Observation ;D 

 
 

 
 
 Comment by: Valuable-World6475
 | Posted (UTC): 2025-01-02
 | Score: 13
 
 LLM coding is like a gauss sampler. just do it enough times will get near to the best answer. 


 
 
 Comment by: Revolutionalredstone
 | Posted (UTC): 2025-01-02
 | Score: 12
 
 Literally! sounds insane but a good filter and a million guesses is not a bad approximation of a genius ;D 


 
 
 Comment by: Shinobi_Sanin33
 | Posted (UTC): 2025-01-03
 | Score: 1
 
 "I didn’t fail 1,000 times. The light bulb was an invention with 1,000 steps." - Thomas Edison This is going to increasingly ring true louder now more than ever before. 

 
 
 
 More comments truncated...


id: 1a7b586fdac4
title: jeecgboot/JeecgBoot
summary: JeecgBoot是一个AI低代码平台，通过强大的代码生成器实现前后端一键生成，集成LLM、RAG、知识库等AI功能模块。该平台显著提升开发效率、降低成本，适合企业快速构建低代码解决方案和AI应用。
source_url: https://github.com/jeecgboot/JeecgBoot
source_platform: github
author: jeecgboot
published_at: 2026-03-02T09:32:59+00:00
collected_at: 2026-03-02T23:01:07.367845+00:00
scenario_type: 代码生成与审查
novelty: similar
similar_to_ids: ["aea12527477e", "2009754ac555", "1e4478d8d921"]
tools_used:
["JeecgBoot", "AI low-code platform", "code generator", "Spring Boot", "Vue3", "LangChain4j", "Spring AI", "DeepSeek", "MCP", "RAG", "Activiti", "Flowable"]

raw_content:
jeecgboot/JeecgBoot

【AI低代码平台】AI low-code platform empowers enterprises to quickly develop low-code solutions and build AI applications.  助力企业快速实现低代码开发和构建AI应用！ AI应用平台涵盖：AI应用、AI模型、AI聊天助手、知识库、AI流程编排、MCP和插件，聊天式业务操作等。 强大代码生成器：实现前后端一键生成，无需手写代码! 显著提升效率节省成本，又不失灵活~

Topics: activiti, agent, ai, aiflow, ant-design-vue, antd, codegenerator, deepseek, flowable, langchain4j, llm, low-code, mcp, mybatis-plus, rag, spring-ai, springboot, springboot3, springcloud, vue3
Language: Java | Stars: 45313


id: da5e5724c2e9
title: CopilotKit/CopilotKit
source_url: https://github.com/CopilotKit/CopilotKit
source_platform: github
author: CopilotKit
published_at: 2026-03-02T21:59:03+00:00
collected_at: 2026-03-02T23:01:48.037876+00:00
scenario_type: 代码生成与审查
tools_used: ["CopilotKit", "React", "Angular", "TypeScript", "Next.js"]
novelty: similar
similar_to_ids: ["aea12527477e", "2009754ac555", "1e4478d8d921"]
summary:
CopilotKit是一个开源框架，为React和Angular应用提供AI代理和生成式UI功能，使开发者能够轻松集成AI助手和Copilot功能。该项目通过TypeScript和Next.js支持，为前端应用赋能AI能力，具有较高的实践应用价值。

raw_content:
CopilotKit/CopilotKit

The Frontend for Agents & Generative UI. React + Angular

Topics: agent, agent-native, agentic-ai, agents, ai, ai-agent, ai-assistant, assistant, assistant-chat-bots, copilot, copilot-chat, generative-ui, js, llm, nextjs, open-source, react, reactjs, ts, typescript
Language: TypeScript | Stars: 29124


id: faa318861b48
title: github/github-mcp-server
source_url: https://github.com/github/github-mcp-server
source_platform: github
author: github
published_at: 2026-03-02T18:19:27+00:00
collected_at: 2026-03-02T23:01:55.007236+00:00
scenario_type: 终端与CLI增强
tools_used: ["GitHub MCP Server", "Go"]
novelty: similar
similar_to_ids: ["928c8ca86708", "25bff0b4a0ec"]
summary:
这是GitHub官方发布的MCP服务器实现，使用Go语言开发，允许开发者通过MCP协议集成GitHub功能到本地CLI工具中。该项目为开发者提供了便捷的GitHub API访问接口，增强了终端工作流的效率。

raw_content:
github/github-mcp-server

GitHub's official MCP Server

Topics: github, mcp, mcp-server
Language: Go | Stars: 27393


id: cba07222d406
title: flipped-aurora/gin-vue-admin
source_url: https://github.com/flipped-aurora/gin-vue-admin
source_platform: github
author: flipped-aurora
published_at: 2026-03-02T11:57:38+00:00
collected_at: 2026-03-02T23:02:21.267785+00:00
scenario_type: 代码生成与审查
tools_used: ["Vite", "Vue3", "Gin", "JWT", "Casbin", "GORM", "Element-UI", "MCP", "代码生成器", "表单生成器"]
novelty: similar
similar_to_ids: ["1a7b586fdac4", "aea12527477e"]
summary:
这是一个基于Vite+Vue3+Gin的企业级开发平台，集成了AI辅助功能、MCP服务和skills管理，提供代码生成器、表单生成器等开发工具。该项目通过内置的代码生成和动态配置能力，显著提升了开发效率和企业应用开发的规范性。

raw_content:
flipped-aurora/gin-vue-admin

🚀Vite+Vue3+Gin拥有AI辅助的基础开发平台，企业级业务AI+开发解决方案，内置mcp辅助服务，内置skills管理，支持TS和JS混用。它集成了JWT鉴权、权限管理、动态路由、显隐可控组件、分页封装、多点登录拦截、资源权限、上传下载、代码生成器、表单生成器和可配置的导入导出等开发必备功能。

Topics: admin, ai, casbin, element-ui, gin, gin-admin, gin-vue-admin, go, go-admin, golang, gorm, i18n, jwt, mcp, skills, vibecoding, vite, vue, vue-admin, vue3
Language: Go | Stars: 24364


id: 52d44a688882
title: farion1231/cc-switch
source_url: https://github.com/farion1231/cc-switch
source_platform: github
author: farion1231
published_at: 2026-03-02T03:34:11+00:00
collected_at: 2026-03-02T23:02:34.617308+00:00
scenario_type: 终端与CLI增强
tools_used: ["Claude Code", "Codex", "OpenCode", "Gemini CLI", "Tauri", "TypeScript"]
novelty: similar
similar_to_ids: ["1d33fcd888f9", "275d929bfde7", "0b5c4741d1c1"]
summary:
这是一个跨平台桌面应用，为多个AI CLI工具（Claude Code、Codex、OpenCode和Gemini）提供统一的All-in-One助手界面。该工具使用Tauri和TypeScript构建，支持提供商管理、技能管理和WSL支持，显著提升了开发者使用多个AI编码工具的效率。

raw_content:
farion1231/cc-switch

A cross-platform desktop All-in-One assistant tool for Claude Code, Codex, OpenCode & Gemini CLI.

Topics: ai-tools, claude-code, codex, desktop-app, kimi-k2-thiking, mcp, minimax, open-source, opencode, provider-management, rust, skills, skills-management, tauri, typescript, wsl-support
Language: TypeScript | Stars: 22673


id: 561dbb212aaf
title: Show HN: Now I Get It – Translate scientific papers into interactive webpages
summary: 该应用通过LLM将科学论文自动转换为交互式网页，为研究人员提供快速理解论文的入口。利用智能体工程和AWS基础设施构建，降低了科学文献阅读的认知负担。虽然主要是便利工具，但在学术领域具有实际应用价值。
source_url: https://nowigetit.us
source_platform: hackernews
author: jbdamask
published_at: 2026-02-28T13:29:36+00:00
collected_at: 2026-03-03T23:02:26.603155+00:00
scenario_type: 文档与内容处理
tools_used: ["Claude LLM", "AWS", "Beads", "Beads Viewer", "Destructive Command Guard"]
novelty: similar
similar_to_ids: ["c9325c12e92c"]
raw_content:
Show HN: Now I Get It – Translate scientific papers into interactive webpages

Understanding scientific articles can be tough, even in your own field. Trying to comprehend articles from others? Good luck.<p>Enter, Now I Get It!<p>I made this app for curious people. Simply upload an article and after a few minutes you&#x27;ll have an interactive web page showcasing the highlights. Generated pages are stored in the cloud and can be viewed from a gallery.<p>Now I Get It! uses the best LLMs out there, which means the app will improve as AI improves.<p>Free for now - it&#x27;s capped at 20 articles per day so I don&#x27;t burn cash.<p>A few things I (and maybe you will) find interesting:<p>* This is a pure convenience app. I could just as well use a saved prompt in Claude, but sometimes it&#x27;s nice to have a niche-focused app. It&#x27;s just cognitively easier, IMO.<p>* The app was built for myself and colleagues in various scientific fields. It can take an hour or more to read a detailed paper so this is like an on-ramp.<p>* The app is a place for me to experiment with using LLMs to translate scientific articles into software. The space is pregnant with possibilities.<p>* Everything in the app is the result of agentic engineering, e.g. plans, specs, tasks, execution loops. I swear by Beads (<a href="https:&#x2F;&#x2F;github.com&#x2F;steveyegge&#x2F;beads" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;steveyegge&#x2F;beads</a>) by Yegge and also make heavy use of Beads Viewer (<a href="https:&#x2F;&#x2F;news.ycombinator.com&#x2F;item?id=46314423">https:&#x2F;&#x2F;news.ycombinator.com&#x2F;item?id=46314423</a>) and Destructive Command Guard (<a href="https:&#x2F;&#x2F;news.ycombinator.com&#x2F;item?id=46835674">https:&#x2F;&#x2F;news.ycombinator.com&#x2F;item?id=46835674</a>) by Jeffrey Emanuel.<p>* I&#x27;m an AWS fan and have been impressed by Opus&#x27; ability to write good CFN. It still needs a bunch of guidance around distributed architecture but way better than last year.


id: bc0fb2ea1445
title: danny-avila/LibreChat
source_url: https://github.com/danny-avila/LibreChat
source_platform: github
author: danny-avila
published_at: 2026-03-05T03:01:10+00:00
collected_at: 2026-03-05T03:18:02.479596+00:00
scenario_type: 工作流自动化
novelty: similar
similar_to_ids: ["a44c7aa65560", "97dcab4759c8", "c37165a31cd3"]
summary:
LibreChat是一个开源的自托管ChatGPT克隆平台，集成多个AI模型和工具，支持AI代理、消息搜索、代码解释等功能。该项目通过统一接口整合多个AI服务，适合需要自建、多模型切换的企业级工作流自动化场景。

tools_used:
["LibreChat", "Claude", "ChatGPT", "DeepSeek", "Gemini", "OpenAI", "Azure", "AWS", "Groq", "Mistral", "DALL-E-3", "MCP", "Code Interpreter", "LangChain"]

raw_content:
danny-avila/LibreChat

Enhanced ChatGPT Clone: Features Agents, MCP, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active.

Topics: ai, anthropic, artifacts, aws, azure, chatgpt, chatgpt-clone, claude, clone, deepseek, gemini, google, gpt-5, librechat, mcp, o1, openai, responses-api, vision, webui
Language: TypeScript | Stars: 34342


id: ba31bde2dfc2
title: microsoft/playwright-mcp
source_url: https://github.com/microsoft/playwright-mcp
source_platform: github
author: microsoft
published_at: 2026-03-05T02:38:40+00:00
collected_at: 2026-03-05T03:18:43.574349+00:00
scenario_type: 终端与CLI增强
tools_used: ["Playwright", "MCP (Model Context Protocol)", "TypeScript"]
novelty: similar
similar_to_ids: ["faa318861b48", "928c8ca86708"]
summary:
这是一个基于Playwright的MCP服务器实现，用TypeScript开发，使Claude能够通过Model Context Protocol与Playwright浏览器自动化工具集成。该方案提升了Claude在Web自动化、测试和数据抓取等任务中的能力，具有较高的实用价值。

raw_content:
microsoft/playwright-mcp

Playwright MCP server

Topics: mcp, playwright
Language: TypeScript | Stars: 28158


id: a6ba47795183
title: Has anyone actually deployed AI agents in production? : r/singularity
source_url: https://www.reddit.com/r/singularity/comments/1emfcw3/has_anyone_actually_deployed_ai_agents_in/
source_platform: reddit
author: exizt
published_at: 2026-03-05T03:45:54.403552+00:00
collected_at: 2026-03-05T03:46:22.331701+00:00
scenario_type: 商业流程自动化
tools_used: ["AI agents", "customer support automation", "myaskai.com", "Intercom", "Zendesk", "customer.io"]
novelty: new
similar_to_ids: []
summary:
讨论了AI代理在生产环境中的实际部署情况，重点关注客户支持自动化领域。根据实际案例，一些公司已成功部署AI代理处理客户工单，达到75%的自动解决率，但整体采用率仍然较低，主要受限于成本考虑和质量担忧。

raw_content:
Has anyone actually deployed AI agents in production? : r/singularity


 Has anyone actually deployed AI agents in production? 
 Author: exizt 
 Time Posted (UTC): 2024-08-07 15:50:50+00:00 
 Score: 125 
 


 
 Link: https://www.reddit.com/r/singularity/comments/1emfcw3/has_anyone_actually_deployed_ai_agents_in/ 
 


 
 Everyone is talking about how AI is going to take our jobs. But I’ve been developing an AI agent to help with customer support for a while, and it doesn’t feel production ready at all. It keeps hallucinating, mixing up product information and losing context. Has anyone managed to deploy an AI agent in production at a significant scale? How did you do that? 
 


 
 Comments 
 


 
 
 Comment by: rainman100
 | Posted (UTC): 2024-08-07
 | Score: 100
 
 Speaking as the founder of myaskai.com — there are definitely a decent number of companies using AI agents in production. We have customer.io (email automation SaaS) using our product in production as well as a number of other companies each with 10,000+ tickets/mo — who are seeing \~75% of their tickets completely resolved by AI. But obviously uptake overall is still very low. We focus on SaaS and also some B2C use cases, and it's incredibly surprising (I think) how few companies are using any form of AI for their customer support when we're scanning the market. For example, take all the companies using Intercom, at the flick of a switch, they can turn on (good) AI customer support. But they choose not to. Why? Firstly, I think Intercom (and Zendesk) are waayyy overcharing at $1-1.5 per AI resolved conversation. Secondly, companies are worried that the quality won't be good enough. We're naturally bullish on this space for a few reasons (same reasons I'm surpirsed uptake is still so low): 1. The quality, even today, is very good. We're seeing on average 75% of conversations resolved by AI, with no disernable difference in CSAT scores. Reviewing the AI <> customer conversations, I'm always taken a back at how empathetic and smart the AI agent is at resolving simple or complex questions. 2. Quality, speed and cost are all getting better, fast. So AI resolution rates will continue to climb to the high 90%s in the next year or so. 3. Even if you assume that AI agents will only be good for 50% of your support tickets. That's still phenomenal. Half of your support tickets deflected automatically. Leaving your agents to spend their time on more important work e.g. proactive support, onboarding high value customer, high complexity tickets. One challenge at the moment is the sheer number of AI customer support solutions, where only a small sub-set are actually meeting or surpassing expectations. So I think a lot of companies have had a bad experience and have been put off by that. Of course I would say this, but I'm very certain that we'll look back in 5 years and be amazed how much basic customer support human agents did. 


 
 
 Comment by: joey_m4v
 | Posted (UTC): 2024-08-07
 | Score: 15
 
 This is a super detailed answer, thanks a bunch. If you're able to share, what kind of industries are your present clients for customer.io in? 10,000 tickets/mo at a 75% solve rate is wild! 


 
 
 Comment by: rainman100
 | Posted (UTC): 2024-08-07
 | Score: 9
 
 You're welcome! Sorry, the business is myaskai.com, Customer.io is one of our customers. The majority of our customers are either SaaS businesses or B2C businesses (apps/digital products). We're actually seeing 75% resolution rate across 35k tickets/mo (just that some clients have 10k/mo themselves). 


 
 
 Comment by: staladine
 | Posted (UTC): 2024-08-07
 | Score: 4
 
 Question if you don't mind. I am in a market / country that does not allow their data offshore. Can your solution work on prem or in local isolated clouds or is it running on your servers ? I have many clients that would benefit from your solution, btw love the site thanks for sharing, and would love to use it but only if it's local. 


 
 
 Comment by: often_says_nice
 | Posted (UTC): 2024-08-08
 | Score: 3
 
 Just curious, when this kind of on-prem requirement exists, is a viable solution to provide a docker container that customers can deploy from their aws/gcp environment? I imagine hosting on-prem LLM infra is not cost effective otherwise 

 

 
 
 Comment by: Intrepid-Car-9611
 | Posted (UTC): 2024-12-06
 | Score: 1
 
 Aisera can do onprem or in private cloud. Can message me if you want to know more 

 

 
 
 Comment by: rainman100
 | Posted (UTC): 2024-08-08
 | Score: 1
 
 Unfortunately we don't have a local/on-prem option right now :( 

 
 
 
 

 
 
 Comment by: CanYouPleaseChill
 | Posted (UTC): 2024-08-07
 | Score: 4
 
 Why is it surprising? Most people want to talk to a human when they need customer support, not a chatbot. A chatbot just says the company is lazy and doesn’t give a damn. 


 
 
 Comment by: i_give_you_gum
 | Posted (UTC): 2024-08-08
 | Score: 10
 
 If it gets what I need done quickly and efficiently, I don't care, I have spoken to some horrifically bad human tech and billing support people. Save the humans for ultra complex issues. My DMV has an AI chatbot to renew registration online and it's a breeze. Meanwhile I've had 3 different answers from the ACA about healthcare costs, and one person who had ZERO clue what they were doing. Humans aren't that great. 


 
 
 Comment by: No_Opening9605
 | Posted (UTC): 2024-08-11
 | Score: 2
 
 Thank you! In all of these deployments it would be grounding to see the pre-AI human correct response rate. Was it 99% resolution rate on the first call? Doubt it! That’s not to say that customers value human and AI interaction equally. It is far easier to rage against an automated process than a person (although that happens all the time too). My suggestion - don’t hide any of this from your customers. - Display the prior resolution rate. - Display the AI resolution rate. - Display how to switch to a human. - Display the CSAT of AI cases (at least internally) People want their intelligence and autonomy respected. They primarily want their issue addressed and they don’t want to be beholden to someone else’s inflexible process. Fix their issues as quickly & effectively as possible and give them options when that isn’t happening. 

 

 
 
 Comment by: rainman100
 | Posted (UTC): 2024-08-08
 | Score: 1
 
 This is such a great point!! 

 
 

 
 
 Comment by: rainman100
 | Posted (UTC): 2024-08-08
 | Score: 1
 
 I think this is the key message (comment below): "If it gets what I need done quickly and efficiently, I don't care, I have spoken to some horrifically bad human tech and billing support people." We assume "humans are better", but they're not always. They can be rude, but most importantly they can be very very slow to respond. It might take hours or days to respond to a fairly basic request e.g. "How do I reset my API key". Wouldn't you rather the AI try to answer first (within 10 seconds) and then if that doesn't help you can ask to speak to someone? 

 

 
 
 Comment by: zorgle99
 | Posted (UTC): 2024-08-08
 | Score: 1
 
 That's the old way of thinking, that will change now that bots are smart, people will prefer them to real people very soon. 


 
 
 Comment by: CanYouPleaseChill
 | Posted (UTC): 2024-08-08
 | Score: 2
 
 Bots aren't smart and humans preferring to talk to humans when they have issues isn't some old-fashioned notion, it's a basic fact that isn't going to change. 


 
 
 Comment by: zorgle99
 | Posted (UTC): 2024-08-09
 | Score: 1
 
 It's already changed in the younger generation, character.ai is wildly popular as are virtual AI friends. 

 

 
 
 Comment by: TackleLoose6363
 | Posted (UTC): 2024-08-25
 | Score: 1
 
 This is horribly short sighted 

 
 
 
 

 
 
 Comment by: phira
 | Posted (UTC): 2024-08-07
 | Score: 3
 
 Intercom has a very good product though, they were relatively early to market but their agent is damn near bullet proof (worth the money if your regulated or adjacent) and they’ve continued to iterate well. The cost efficiencies are still there and charging for success only makes everyone feel better about adoption. 


 
 
 Comment by: rainman100
 | Posted (UTC): 2024-08-07
 | Score: 3
 
 Yeah, defo a good product and of the big players, they're leading. But if you're receiving 30k+ tickets per month, the cost savings to a cheaper provider (e.g. myaskai.com) are not insignificant. For a smaller startup as well, it's like $100/mo vs. $500/mo (with Intercom), so it might still be good value for money, but it could be even better value for money :) 


 
 
 Comment by: phira
 | Posted (UTC): 2024-08-07
 | Score: 5
 
 Have you been seeing the same stuff we did with email? People seem to really like AI in chat but as an email responder it seems less accepted. Or theory is that people just have a stronger expectation that they’re gonna get a human via email 


 
 
 Comment by: rainman100
 | Posted (UTC): 2024-08-08
 | Score: 2
 
 We see very similar resolution rates with email to be honest. And we take a slightly more advaced approach with email where we: identify all question in the email > answer these individually > create a final exhaustive response. But you're right, there is definitely a different expecation with email. With our chat and with email AI agent though, we make it clear the answer are from an AI agent and are automated. We also make it clear how they can speak to a person if they need to. 


 
 
 Comment by: phira
 | Posted (UTC): 2024-08-08
 | Score: 1
 
 Interesting! Thanks! 

 
 
 
 
 

 
 
 Comment by: Opposite_Language_19
 | Posted (UTC): 2024-08-07
 | Score: 2
 
 If you could build a solution to import email inboxes and parse to auto populate a zendesk knowledge base that then is usable with your tool, you could seriously onboard hundreds and thousands. Marketing manager here at 5 manufacturing companies with 40 SKUs and would be happy to help alongside acquiring 3-5 licences! 👍👍👍 


 
 
 Comment by: rainman100
 | Posted (UTC): 2024-08-08
 | Score: 1
 
 So we have something very similar today that you might be interested in. (I also love your idea btw!) Right now, when the AI can't answer a question because of insufficient knowledge, we keep a record of those "unanswered questions". We then present these back to your in a dashboard (ranked by frequency and importance) so you can identify where to fill gaps in your knowledge base. We also allow you to sync your Zendesk tickets to help write the content for those knoweldge gaps. Does that sound helpful? 


 
 
 Comment by: Opposite_Language_19
 | Posted (UTC): 2024-08-08
 | Score: 1
 
 Sounds really cool, check your ai chat bot at my recent conversation where I provide my email address and provide context to this thread :) I think tawk.to is an easier solution…. My only concern was having 100 example questions and being able to compose responses on examples of how we would potentially want it to interact reduce chances of that happening…. We can go live from the 19th when I come back from vacation but I have provided my work email… 


 
 
 Comment by: rainman100
 | Posted (UTC): 2024-08-09
 | Score: 1
 
 I couldn't easily find this, sorry, would you be able to DM me this info? 

 
 
 
 

 
 
 Comment by: slamdamnsplits
 | Posted (UTC): 2025-01-01
 | Score: 1
 
 Do you have integrations with smart tab? 

 

 
 
 Comment by: iBoMbY
 | Posted (UTC): 2024-08-07
 | Score: 0
 
 75% of the tickets resolved by, "sorry we can't and won't help you"? The standard of ticket automation for any larger company? 


 
 
 Comment by: rainman100
 | Posted (UTC): 2024-08-08
 | Score: 2
 
 Not sure I follow? For 75% of conversations, the customer hasn't tried or requested to speak to a person. We take this as a positive signal. We make it really clear how they can speak to a person, so it's not like we're trying to create friction with them connecting with the team. 

 
 

 
 
 Comment by: nexusprime2015
 | Posted (UTC): 2024-08-09
 | Score: 0
 
 Hi ChatGPT. 


 
 
 Comment by: rainman100
 | Posted (UTC): 2024-08-09
 | Score: 1
 
 Lol. Is that really your contribution? 

 
 
 

 
 
 Comment by: No-Relationship8261
 | Posted (UTC): 2024-08-07
 | Score: 40
 
 Our company tested copilot and found on average projects took just as long. As converting generated code to be production ready took just as much time as that was saved during development. Though the trial continues in hopes that as AI tools and users imrpoves we will save more time. 


 
 
 Comment by: TomMikeson
 | Posted (UTC): 2024-08-07
 | Score: 11
 
 Same for us.  We beta tested the VS Code addon. The problem is also that people will.get paid the same either way.  They will determine the speed that the work. However, I didn't find it much faster than using Google when I got hung up.  It was good for making a basic program structure, but it doesn't do all the work. Also, it wasn't always correct. 


 
 
 Comment by: No-Relationship8261
 | Posted (UTC): 2024-08-07
 | Score: 7
 
 The problem for us seems to be, if we ask ai stuff like "Can you find what causes this bug in the repo?" it either can't answer or gives a incorrect answer. Surprisingly while creating a new repo, it's helpful. But not crazy good as well, as it inevitably introduces errors. In our experience it's truly just about the same. Nothing related to pay. Though it's easy to imagine how bigger context size and more specialized ai will be affective. Though I can confidently say it's not there for coding yet. In our experience, if you can describe a problem well enough that AI can solve it, you have already solved it. Changing the code often takes less time than explaining the change to AI. Like I said, going from zero is much more promising, but often the mistakes introduced by AI are bad. Because they are also hard to notice by humans. So you basically have to understand the whole project anyway, to understand what to fix. I don't know what that tells us about it. 

 

 
 
 Comment by: No-Relationship8261
 | Posted (UTC): 2024-08-07
 | Score: 4
 
 Our overall review right now is, let alone replacing people. It's not clear if it's worth the subscription. But it holds incredible potential, so it's better that people are familiar with how to use it in the future. Because you know, it's only going to get better. 


 
 
 Comment by: TomMikeson
 | Posted (UTC): 2024-08-07
 | Score: 2
 
 Same  

 
 

 
 
 Comment by: salamisam
 | Posted (UTC): 2024-08-08
 | Score: 1
 
 I am a slow typer so copilot has sped me up a bit, auto-completing param names and types and simple loops etc. The problem I find is that when you use chatgpt you end up spending the same amount of effort explaining the problem so it can understand it, and when using copilot you end up having to spend time reviewing their code or modifying it in some cases. It might write 20 lines of code for you saving you that effort, but then you have to put a different type of effort in reviewing/refactoring. 

 
 

 
 
 Comment by: rgujijtdguibhyy
 | Posted (UTC): 2024-08-07
 | Score: 11
 
 But copilot is not an agent 

 

 
 
 Comment by: EnigmaticDoom
 | Posted (UTC): 2024-08-07
 | Score: 7
 
 Copilot isn't an 'agent'. 

 

 
 
 Comment by: ChomsGP
 | Posted (UTC): 2024-08-07
 | Score: 4
 
 what do you mean by "tested copilot"? if you mean you did test groups developing the same feature with and without AI, I'd love to see some actual numbers, if you mean "our employees have no idea about this but we gave it a try" ehhh sure it is faster to go with what you know than start a new process but that has nothing to do with copilot 


 
 
 Comment by: No-Relationship8261
 | Posted (UTC): 2024-08-07
 | Score: 2
 
 2nd one but over a long period. Its not like we just tried it for a month. It has been ongoing for over a year now 


 
 
 Comment by: ChomsGP
 | Posted (UTC): 2024-08-08
 | Score: 3
 
 I don't doubt it has been longer than a month but a year ago most coding LLMs were damn bad, I work on this stuff and even my ppl is not 100% comfortable using it, I myself invest more time on research than actually using it (yet it has saved me countless hours of work), so I'm inclined to blame the procedure and not the LLM itself in your case, you need to train your guys on how to be productive with genAI and for that you first need to know yourself :) 


 
 
 Comment by: No-Relationship8261
 | Posted (UTC): 2024-08-08
 | Score: 2
 
 Well, even our trial leaders have the same opinion ( High level People pushing for adoption) Btw, I think you have the wrong impression. I am not someone calling the shots. I was just part of and interested in the trial. I am just a normal Software Dev. I don't make any decision that affect the whole company. Like I said, even people most informed about it didn't find it very useful (And it's their job to be informed, they don't do much else :P ) But potential is there, but I doubt anyone is having significant increase in productivity. Though I heard it was better in python or stuff like that. Our codebase includes many languages, but not python. So maybe that is also a factor. 


 
 
 Comment by: ChomsGP
 | Posted (UTC): 2024-08-08
 | Score: 1
 
 hey, I see, for sure the lack of python is a factor and more as you said you are using a custom licensed version, I'm generally not binded to a solution and I found best results are actually achieved by using specific LLMs for each part of the development process, as said the main issue I'm seeing with most "failed" use cases are usually due to a poor understanding on the implementation, there's not a single solution for everything and they all keep evolving, I'd for example use Claude for asking complex pieces of code, Amazon Q for inline code writing, and Bing's gpt4 for general question answering, then you also need to figure out how each piece fits in your team, like, even a subpartsolution like your experience with copilot can be added to specific portions of your development for example just to add the unit testing and that already takes time off it even if you made the code yourself 

 
 

 
 
 Comment by: No-Relationship8261
 | Posted (UTC): 2024-08-08
 | Score: 1
 
 Oh also, we used a special contracted version of copilot and Microsoft is legally liable for both using any open source code (Basically if we get sued we can just forward it to them) + they can't send any of our code anywhere. Maybe that makes it worse than commercial one? I never used the one with potential legal implications. 

 
 
 
 

 
 
 Comment by: reddit_guy666
 | Posted (UTC): 2024-08-07
 | Score: 2
 
 Did you guys achieve it with fewer headcount? AI even if is taking the same amount of time but can deliver it with fewer people then it is still a threat to jobs 


 
 
 Comment by: CanvasFanatic
 | Posted (UTC): 2024-08-07
 | Score: 8
 
 People saying stuff like this really don’t understand where most of the time to get stuff into production actually goes. It’s definitely not rough drafts of the code. It’s testing, configuration, integration, communication and negotiation. Copilot isn’t going to help with any of that. The biggest place it can save you time is maybe in authoring unit tests. People who cut staff are just going to demoralized their developers. Then you’ll all be scratching your heads at why things aren’t working. You’re definitely going to try it though so… 🍿🥤 


 
 
 Comment by: EnigmaticDoom
 | Posted (UTC): 2024-08-07
 | Score: 4
 
 Copilot already helps with all of the above. And for where it fails use the azure open ai api or aws bedrock to fill in the gaps. Also none of the above are 'agentic' solutions out of the box which is what OP is asking about btw. 


 
 
 Comment by: CanvasFanatic
 | Posted (UTC): 2024-08-07
 | Score: 1
 
 Good luck with those 


 
 
 Comment by: EnigmaticDoom
 | Posted (UTC): 2024-08-07
 | Score: 1
 
 No luck required, thats what the AI is for. 


 
 
 Comment by: CanvasFanatic
 | Posted (UTC): 2024-08-07
 | Score: 1
 
 😂 

 
 
 
 
 
 
 
 More comments truncated...


id: 853c63f738f0
title: thedotmack/claude-mem
source_url: https://github.com/thedotmack/claude-mem
source_platform: github
author: thedotmack
published_at: 2026-03-05T22:11:20+00:00
collected_at: 2026-03-06T01:01:51.301386+00:00
scenario_type: 终端与CLI增强
tools_used: ["Claude Code", "Claude agent-sdk", "ChromaDB", "SQLite", "embeddings", "RAG"]
novelty: similar
similar_to_ids: ["3fff252b35ec", "257ed0953657"]
summary:
这是一个Claude Code插件，通过自动捕获编码会话中的所有活动，利用AI压缩并使用向量数据库和RAG技术将相关上下文注入到未来的会话中，实现长期记忆功能。该项目显著增强了Claude在编码工作流中的连续性和上下文感知能力。

raw_content:
thedotmack/claude-mem

A Claude Code plugin that automatically captures everything Claude does during your coding sessions, compresses it with AI (using Claude's agent-sdk), and injects relevant context back into future sessions.

Topics: ai, ai-agents, ai-memory, anthropic, artificial-intelligence, chromadb, claude, claude-agent-sdk, claude-agents, claude-code, claude-code-plugin, claude-skills, embeddings, long-term-memory, mem0, memory-engine, openmemory, rag, sqlite, supermemory
Language: TypeScript | Stars: 33049


id: 17cb059019ed
title: Show HN: Self-host Reddit – 2.38B posts, works offline, yours forever
source_url: https://github.com/19-84/redd-archiver
source_platform: hackernews
author: 19-84
published_at: 2026-01-13T15:35:09+00:00
collected_at: 2026-03-06T01:02:47.175657+00:00
scenario_type: 本地数据集成
tools_used: ["Python", "PostgreSQL", "Jinja2", "Docker", "Claude Code", "REST API", "MCP Server"]
novelty: similar
similar_to_ids: ["df2c22e2bf16", "1e8c9128b5ed", "85b23a6c94bb"]
summary:
用户构建了一个自托管工具，可将2.38B条Reddit帖子转换为可离线浏览的本地存档，支持USB、家庭服务器、Tor隐藏服务等多种部署方式。该工具提供完整的REST API和MCP服务器集成，用户可在本地完全掌控数据，无需依赖Reddit的API或服务条款。

raw_content:
Show HN: Self-host Reddit – 2.38B posts, works offline, yours forever

Reddit&#x27;s API is effectively dead for archival. Third-party apps are gone. Reddit has threatened to cut off access to the Pushshift dataset multiple times. But 3.28TB of Reddit history exists as a torrent right now, and I built a tool to turn it into something you can browse on your own hardware.<p>The key point: This doesn&#x27;t touch Reddit&#x27;s servers. Ever. Download the Pushshift dataset, run my tool locally, get a fully browsable archive. Works on an air-gapped machine. Works on a Raspberry Pi serving your LAN. Works on a USB drive you hand to someone.<p>What it does: Takes compressed data dumps from Reddit (.zst), Voat (SQL), and Ruqqus (.7z) and generates static HTML. No JavaScript, no external requests, no tracking. Open index.html and browse. Want search? Run the optional Docker stack with PostgreSQL – still entirely on your machine.<p>API &amp; AI Integration: Full REST API with 30+ endpoints – posts, comments, users, subreddits, full-text search, aggregations. Also ships with an MCP server (29 tools) so you can query your archive directly from AI tools.<p>Self-hosting options:
 - USB drive &#x2F; local folder (just open the HTML files)
 - Home server on your LAN
 - Tor hidden service (2 commands, no port forwarding needed)
 - VPS with HTTPS
 - GitHub Pages for small archives<p>Why this matters: Once you have the data, you own it. No API keys, no rate limits, no ToS changes can take it away.<p>Scale: Tens of millions of posts per instance. PostgreSQL backend keeps memory constant regardless of dataset size. For the full 2.38B post dataset, run multiple instances by topic.<p>How I built it: Python, PostgreSQL, Jinja2 templates, Docker. Used Claude Code throughout as an experiment in AI-assisted development. Learned that the workflow is &quot;trust but verify&quot; – it accelerates the boring parts but you still own the architecture.<p>Live demo: <a href="https:&#x2F;&#x2F;online-archives.github.io&#x2F;redd-archiver-example&#x2F;" rel="nofollow">https:&#x2F;&#x2F;online-archives.github.io&#x2F;redd-archiver-example&#x2F;</a><p>GitHub: <a href="https:&#x2F;&#x2F;github.com&#x2F;19-84&#x2F;redd-archiver" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;19-84&#x2F;redd-archiver</a> (Public Domain)<p>Pushshift torrent: <a href="https:&#x2F;&#x2F;academictorrents.com&#x2F;details&#x2F;1614740ac8c94505e4ecb9d88be8bed7b6afddd4" rel="nofollow">https:&#x2F;&#x2F;academictorrents.com&#x2F;details&#x2F;1614740ac8c94505e4ecb9d...</a>


id: a90e1fa2514d
title: code-yeongyu/oh-my-openagent
source_url: https://github.com/code-yeongyu/oh-my-openagent
source_platform: github
author: code-yeongyu
published_at: 2026-03-06T23:14:57+00:00
collected_at: 2026-03-07T01:01:11.178136+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude", "Claude Code", "OpenAI", "Gemini", "Cursor IDE"]
novelty: similar
similar_to_ids: ["cba07222d406", "1a7b586fdac4", "aea12527477e", "2009754ac555"]
summary:
这是一个AI代理框架项目，提供多种AI模型集成（Claude、OpenAI、Gemini等）的编程协助能力。该工具通过统一的代理编排界面增强开发工作流程，支持代码生成、审查和IDE集成，具有较强的开发者实用价值。

raw_content:
code-yeongyu/oh-my-openagent

omo; the best agent harness - previously oh-my-opencode

Topics: ai, ai-agents, amp, anthropic, chatgpt, claude, claude-code, claude-skills, cursor, gemini, ide, openai, opencode, orchestration, tui, typescript
Language: TypeScript | Stars: 37600


id: df11630e65be
title: D4Vinci/Scrapling
source_url: https://github.com/D4Vinci/Scrapling
source_platform: github
author: D4Vinci
published_at: 2026-03-06T14:58:19+00:00
collected_at: 2026-03-07T01:01:53.251092+00:00
scenario_type: 工作流自动化
tools_used: ["Scrapling", "Playwright", "MCP Server", "Python"]
novelty: new
similar_to_ids: ["d2fc47980430"]
summary:
Scrapling是一个自适应网页爬虫框架，支持从单个请求到大规模爬取的全流程自动化，集成了Playwright和MCP服务器技术。该工具通过Python实现高效的数据提取和网页爬取工作流，具有隐身机制和灵活的选择器支持。

raw_content:
D4Vinci/Scrapling

🕷️ An adaptive Web Scraping framework that handles everything from a single request to a full-scale crawl!

Topics: ai, ai-scraping, automation, crawler, crawling, crawling-python, data, data-extraction, mcp, mcp-server, playwright, python, scraping, selectors, stealth, web-scraper, web-scraping, web-scraping-python, webscraping, xpath
Language: Python | Stars: 24945


id: a3fc7d534550
title: Show HN: isometric.nyc – giant isometric pixel art map of NYC
summary: 使用AI编码代理和无代码工具生成纽约市大规模等距像素艺术地图，展示了AI在创意内容生成中的应用。虽然未手写代码，但整个项目仍需大量人工干预和工程工作来完成最终交付。
source_url: https://cannoneyed.com/isometric-nyc/
source_platform: hackernews
author: cannoneyed
published_at: 2026-01-22T16:52:35+00:00
collected_at: 2026-03-09T01:00:28.068189+00:00
scenario_type: 创意内容生产
tools_used: ["nano banana", "coding agents", "AI-assisted generation"]
novelty: new
similar_to_ids: []
raw_content:
Show HN: isometric.nyc – giant isometric pixel art map of NYC

Hey HN! I wanted to share something I built over the last few weeks: isometric.nyc is a massive isometric pixel art map of NYC, built with nano banana and coding agents.<p>I didn&#x27;t write a single line of code.<p>Of course no-code doesn&#x27;t mean no-engineering. This project took a lot more manual labor than I&#x27;d hoped!<p>I wrote a deep dive on the workflow and some thoughts about the future of AI coding and creativity:<p><a href="http:&#x2F;&#x2F;cannoneyed.com&#x2F;projects&#x2F;isometric-nyc" rel="nofollow">http:&#x2F;&#x2F;cannoneyed.com&#x2F;projects&#x2F;isometric-nyc</a>


id: 78a5846a75cc
title: AstrBotDevs/AstrBot
source_url: https://github.com/AstrBotDevs/AstrBot
source_platform: github
author: AstrBotDevs
published_at: 2026-03-08T16:20:46+00:00
collected_at: 2026-03-09T01:01:42.356531+00:00
scenario_type: 工作流自动化
tools_used: ["AstrBot", "OpenAI", "Gemini", "Llama", "Discord", "Telegram", "QQ", "Docker", "Python", "MCP"]
novelty: similar
similar_to_ids: ["a44c7aa65560", "bfd43480fcf0", "9c5d4b2c58c4"]
summary:
AstrBot是一个多平台即时通讯聊天机器人基础设施，集成了Discord、Telegram、QQ等多个IM平台以及OpenAI、Gemini、Llama等多个LLM模型，支持插件扩展和AI功能集成。该项目为用户提供了统一的机器人开发框架，可显著提升工作流自动化和跨平台交互效率，特别适合需要多渠道AI助手部署的场景。

raw_content:
AstrBotDevs/AstrBot

Agentic IM Chatbot infrastructure that integrates lots of IM platforms, LLMs, plugins and AI feature, and can be your openclaw alternative. ✨

Topics: agent, ai, chatbot, chatgpt, discord, docker, gemini, gpt, llama, llm, mcp, openai, python, qq, qqbot, telegram
Language: Python | Stars: 19831


id: b9d2abdd810b
title: googleworkspace/cli
source_url: https://github.com/googleworkspace/cli
source_platform: github
author: googleworkspace
published_at: 2026-03-09T00:27:04+00:00
collected_at: 2026-03-09T01:01:54.077374+00:00
scenario_type: 终端与CLI增强
novelty: similar
similar_to_ids: ["faa318861b48", "52d44a688882", "1d33fcd888f9", "275d929bfde7"]
summary:
这是一个统一的Google Workspace命令行工具,支持Drive、Gmail、Calendar、Sheets、Docs、Chat和Admin等多个服务,动态从Google Discovery Service构建,包含AI Agent技能扩展。该工具通过CLI界面提供高效的工作流自动化和生产力增强,特别适合开发者和IT管理员的日常操作。

tools_used:
["Google Workspace CLI", "Google Drive", "Gmail", "Google Calendar", "Google Sheets", "Google Docs", "Google Chat", "Google Admin", "Discovery Service", "Gemini"]

raw_content:
googleworkspace/cli

Google Workspace CLI — one command-line tool for Drive, Gmail, Calendar, Sheets, Docs, Chat, Admin, and more. Dynamically built from Google Discovery Service. Includes AI agent skills.

Topics: agent-skills, ai-agent, automation, cli, discovery-api, gemini-cli-extension, google-admin, google-api, google-calendar, google-chat, google-docs, google-drive, google-sheets, google-workspace, oauth2, rust
Language: Rust | Stars: 16320


id: cebb6abe12ab
title: RightNow-AI/openfang
summary: OpenFang是一个开源的Agent操作系统，采用Rust语言开发，提供了完整的Agent框架和LLM集成能力。该项目通过MCP协议支持多种工具和模型，可用于构建自动化的AI工作流和智能代理系统。
source_url: https://github.com/RightNow-AI/openfang
source_platform: github
author: RightNow-AI
published_at: 2026-03-09T00:20:56+00:00
collected_at: 2026-03-09T01:02:07.973729+00:00
scenario_type: 工作流自动化
tools_used: ["Agent Framework", "LLM", "MCP", "Rust"]
novelty: similar
similar_to_ids: ["6885ba6c5ca2", "5471379ee4ff", "97dcab4759c8"]
raw_content:
RightNow-AI/openfang

Open-source Agent Operating System

Topics: agent-framework, ai-agents, llm, mcp, open-source, openclaw, operating-system, rust
Language: Rust | Stars: 12758


id: bf709374985d
title: Ask HN: How can I get better at using AI for programming?
source_url: https://news.ycombinator.com/item?id=46255285
source_platform: hackernews
author: lemonlime227
published_at: 2025-12-13T15:37:16+00:00
collected_at: 2026-03-10T01:01:05.219163+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude Code", "SvelteKit", "Django", "Storybook", "Tailwind CSS"]
novelty: similar
similar_to_ids: ["a90e1fa2514d", "8b8b74bdb5b3", "f7abc3c22065", "4e8f450b17be", "c4c047193758"]
summary:
用户在将jQuery+Django项目重写为SvelteKit时，希望利用AI辅助编程来加速开发流程，但目前AI生成的代码质量不理想。该用场景涉及代码生成、审查和优化，具有明确的工作流改进目标（将1-2小时的手工翻译工作减少到15-20分钟审查）。

raw_content:
Ask HN: How can I get better at using AI for programming?

I&#x27;ve been working on a personal project recently, rewriting an old jQuery + Django project into SvelteKit. The main work is translating the UI templates into idiomatic SvelteKit while maintaining the original styling. This includes things like using semantic HTML instead of div-spamming, not wrapping divs in divs in divs, and replacing bootstrap with minimal tailwind. It also includes some logic refactors, to maintain the original functionality but rewritten to avoid years of code debt. Things like replacing templates using boolean flags for multiple views with composable Svelte components.<p>I&#x27;ve had a fairly steady process for doing this: look at each route defined in Django, build out my `+page.server.ts`, and then split each major section of the page into a Svelte component with a matching Storybook story. It takes a lot of time to do this, since I have to ensure I&#x27;m not just copying the template but rather recreating it in a more idiomatic style.<p>This kind of work seems like a great use case for AI assisted programming, but I&#x27;ve failed to use it effectively. At most, I can only get Claude Code to recreate some slightly less spaghetti code in Svelte. Simple prompting just isn&#x27;t able to get AI&#x27;s code quality within 90% of what I&#x27;d write by hand. Ideally, AI could get it&#x27;s code to something I could review manually in 15-20 minutes, which would massively speed up the time spent on this project (right now it takes me 1-2 hours to properly translate a route).<p>Do you guys have tips or suggestions on how to improve my efficiency and code quality with AI?


id: 93d2c2bcd5d9
title: Things I wish someone told me before I almost gave up on OpenClaw : r/openclaw
source_url: https://www.reddit.com/r/openclaw/comments/1r71you/things_i_wish_someone_told_me_before_i_almost/
source_platform: reddit
author: unknown
published_at: 2026-03-11T01:00:09.094541+00:00
collected_at: 2026-03-11T01:00:31.278631+00:00
scenario_type: 工作流自动化
tools_used: ["OpenClaw", "Claude API", "Ollama", "Notion", "SQLite", "Cron"]
novelty: similar
similar_to_ids: ["bfd43480fcf0", "6885ba6c5ca2", "5471379ee4ff"]
summary:
这是一篇关于优化OpenClaw（Claude的CLI工作流工具）使用的经验分享文章。作者通过分层模型配置、添加明确规则、使用持久化队列和状态管理等六大策略，解决了token消耗过高和代理循环问题，将成本降低了90%以上，使自动化工作流变得可靠高效。

raw_content:
Things I wish someone told me before I almost gave up on OpenClaw : r/openclaw

Things I wish someone told me before I almost gave up on OpenClaw : r/openclaw Skip to main content Things I wish someone told me before I almost gave up on OpenClaw : r/openclaw

Go to openclaw

r/openclaw 2d ago

NoRecognition3349

# Things I wish someone told me before I almost gave up on OpenClaw

I've been in the same boat as a lot of people here spending the first two weeks babysitting, burning tokens, and watching my agent loop on the same answer eight times in a row.

After a lot of trial and error I've got it running reliably and actually doing useful work. Here's what made the difference for me. This is all available in more detail with all the actual config examples, terminal commands, a model comparison table, and a common issues FAQ here if anyone wants the full version

1. Don't run everything through your best mode

This is the single biggest mistake. Heartbeats, cron checks, and routine tasks don't need Opus or Sonnet. Set up a tiered model config. Use a cheap model (Haiku, Gemini Flash, or even a local model via Ollama) as your primary for general tasks, and keep a stronger model as a fallback. Some people have got per request costs from 20-40k tokens down to like 1.5k just by routing smarter. You can switch models mid-session with /model too.

2. Your agent needs rules. A lot of them.

Out of the box OpenClaw is dumb. It will loop, repeat itself, forget context, and make weird decisions. You need to add guardrails to keep it in check. Create skills (SKILL.md files in your workspace/skills/ folder) that explicitly tell it how to behave. Anti-looping rules, compaction summaries, task checking before asking you questions. The agents that work well are the ones with heavily customised instruction sets. YOU MUST RESEARCH YOURSELF and not assume the agent knows everything. You are a conductor, so conduct.

3. "Work on this overnight" doesn't work the way you think

If you ask your agent to work on something and then close the chat, it forgets. Sessions are stateful only while open. For background work you need cron jobs with isolated sesssion targets. This spins up independent agent sessions that run on a schedule and message you results. One-off deferred tasks need a queue (Notion, SQLite, text file) paired with a cron that checks the queue.

4. Start with one thing working end-to-end

Don't try to set up email + calendar + Telegram + web scraping + cron jobs all at once. Every integration is a separate failure mode. Get one single workflow working perfectly like a morning briefing cron then add the next. Run openclaw doctor --fix if things are broken.

5. Save what works

Compaction loses context over time. Use state files, fill in your workspace docs (USER.md, AGENTS.md, HEARTBEAT.md), and store important decisions somewhere persistent. The less your agent has to re-learn, the better it performs.

6. The model matters more than anything

Most frustration comes from models that can't handle tool calls reliably. Chat quality ≠ agent quality. Claude Sonnet/Opus, GPT-5.2, and Kimi K2 via API handle tool calls well. Avoid DeepSeek Reasoner specifically (great reasoning, malformed tool calls). GPT-5.1 Mini is very cheap but multiple people here have called it "pretty useless" for agent work.

7. You're not bad at this. It's genuinely hard right now

OpenClaw is not a finished product. The people posting "my agent built a full app overnight" have spent weeks tuning. The gap between the demo and daily use is real. It's closing fast, but it's still there.

Hope this helps someone before they give up. Happy to answer questions if anyone's stuck on a specific part.

Read more

Share

---

• Promoted

Parallel Claude Code agents without the frenzy. Try Tonkotsu FREE.

---

AutoModerator

2d ago

Moderator Announcement Read More »

1

cryptopolymath

2d ago

I view OpenClaw like a new hire, they are going to make mistakes during training and it will take a few weeks / months to ramp up.

61

NoRecognition3349

2d ago

Exactly. Treat it like a junior employee.

10

cryptodiemus

2d ago

Lots of reverse prompting

4

5 more replies

Continue this thread 2 more replies

Continue this thread 14 more replies

Continue this thread

GoofMoof

2d ago

Thanks for the inspiration and “you’re not bad at this” - I’m wondering from time to time ;) Specifically about Kimi: I really burn a lot of money with Sonnet helping me with debugging and some sys admin stuff. Would you say Kimi can handle that equally? A always fear that “cheaper models” will mess up my system but chances are also high that I’m overestimating the complexity of these tasks :)

8

NoRecognition3349

2d ago

ha! You're definitely not alone on that one. You're probably right what you're overestimating the complexity. Most sysadmin stuff is actually fairly structured and pattern based do that would be the kind of thing a cheaper modal could handle well.

On kimi specifically, for routine and well-scoped tasks, it's genuinely good value. Sonnet probably pulls ahead on ambiguous problems but then again, I use Anthropic modals more than I use Kimi so I might be a little bias lol.

In any case, I'd suggest not to switch wholesale. Set Mini as your primary and keep sonnet as a fallback. Pay attention to when your cheaper modal fails you. You might be surprised how rarely you actually need sonnet. I almost feel like the expensive modals are buzz words sometimes and no real benefit to the average user aside from specific areas.

The worst case isn't Kimi breaks your system btw, it's Kimi suggests something wrong and you run it without checking. That risk exists with every model including Sonnet. The real safety net is the same regardless of model: read what it suggests before you run it, especially anything with`rm`,`chmod`, config rewrites, or service restarts. That habit matters way more than which model you pick.

TRUST BUT VERIFY! I have a tool that can help you with this if you ever want to try it, let me know.

3

7 more replies

Continue this thread Continue this thread

teachmehowtodougie

2d ago

Hi there,

I totally agree with everything you said! I have been working on this for a while which helps smooth a lot of the edges you have been battling with. I am going to be updating the pipeline flow to make openclaw better at cron aka work on this overnight in the next couple of days. I would try this plugin and see if it works.

https://clawhub.ai/kevinodell/lily-memory

6

1 more reply

Continue this thread

• Promoted

Try Apollo AI for free and see what fast really looks like.

Traxendre

2d ago

Good call thanks, do you think a cheaper model like gtp4o is ok? or 5.2 is way more better and worth the price? (for globaly simple tasks)

4

NoRecognition3349

2d ago

Honestly for globally simple tasks, gpt4o is probably fine. It sstill considered a "good" all rounder and pretty decent tool calling support. Way cheaper than 5.2 anyway.

BUT the real answer is that you shouldn't be picking one modal for everything. Use something cheap as your primary (GPT-4o, Haiku, or even GPT-4o-mini for really simple stuff) and keep 5.2 or Sonnet as a fallback for when the agent actually needs to think harder (or even opus if you can afford it)

Where GPT-5.2 pulls ahead is reliability on longer tool call sequences. If your agent is doing simple stuff like checking a feed, sending a message, basic Q&A, well then 4o handles that no problem. If it's doing something like "read this page, extract the data, format it, then post it somewhere" with 4 or 5 chained tool calls, that's where 5.2 (or Sonnet) makes fewer mistakes and saves you the headache.

Another thing is, you can't depend on the agent for all research and to be right about everything. You MUST do your own research. Trust the agent but verify what its telling you. I have a tool that i use for a lot of research and automates sending the research to the agent which makes things flow a lot better. Can send to you if you want it.

As an FYI. A tool chain is when the agent needs to use multiple tools in sequence to complete a single task, where each step depends on the output of the previous one.

For example, if you tell your agent "check Moltbook for new DMs and summarize them to me on Telegram," the agent has to

Call the DM check API (tool call 1)

Read the response and figure out which conversations have unread message

Fetch the actual messages from each conversation (tool call 2, 3, maybe even 4)

Summarize the content (reasoning)

Send that summary to you via Telegram (tool call 5)

Sorry for the long answer. Hope it helps.

6

10 more replies

Continue this thread 1 more reply

Continue this thread

Bakkario

2d ago

Have you tried local LLM specifically GPT-OSS 20B? Or qwen 3 14B?

4

zipzag

2d ago

I have found local models run out of context space if used for chat. But I'm new at OC. I have had very good luck with gpt-oss-120B with home assistant. But not with OC.

Based on feedback here you should be able to use the two smaller models for heartbeat. However my OC Opus is concerned with these models as being too small.

3

Bakkario

2d ago

Thanks 🙏🏾

3

1 more reply

Continue this thread 3 more replies

Continue this thread

Hc110-1-40-5min-70F

2d ago

One thing I felt helped enormously is don’t use open claw to debug itself. Open up a Claude code in the terminal and have it work on configuring open claw so you’re on a plan rather than burning credits through the API.

4

1 more reply

Continue this thread

andysor

2d ago

My main issue is the absurdly large request token volume. I have a lot of home automation stuff and it sends the entire list of everything in my whole house whenever I ask it something, easily 80-150k tokens, and it sends 5-6 API requests for every prompt I give it. Sure, there's token caching, but after a tiny bit of message history I'm at nearly 1M tokens just to ask it to turn down the lights or open the blinds.Even with 3 flash preview it gets prohibitively expensive fast.

4

15 more replies

Continue this thread

• Promoted

Everything for work. In one place.

gent861

2d ago

But where are some examples of how to configure it. How to optimize the input so it wont spend all tokens? Do you have any github repos with samples skills or anything.

I have mine run and checked his folder aaand it was full of crapy scripts here and there npl packages and even anothe .openclaw folder.. so i did purge it instantly

3

NoRecognition3349

2d ago

Ha yeah this is a rite of passage lol. That happens when the agent doesn't have clear boundaries on where it's allowed to work. Two things fix it:

First set a workplace directory explicitly and add rules about saying in it. Create a SKILL.md file and set some rules like:

`## File System Rules``Only create files inside ~/.openclaw/workspace/``Never install npm packages globally``Never create folders outside the workspace``Ask before creating any new directory.`

Second, the config examples you're looking for are actually in the full article: https://clawfy.xyz/guide-openclaw-tips the code blocks are all copyable. The model routing config, the cron job setup, the guardrail SKILL.md, etc those are all real configs you can paste directly into your setup. The model comparison table is in there too.

For the token optimization question specifically, the biggest lever is the tiered model config from tip 1 in the article. Most people's token spend is 80% heartbeats and routine stuff that doesn't need an expensive model. Switch your primary to something cheap (Haiku, Gemini Flash, whatever) and keep the smart model as a fallback. That alone usually cuts costs dramatically.

The purge was probably the right call btw. Clean workspace, add the filesystem rules, and it won't happen again.

4

1 more reply

Continue this thread 1 more reply

Continue this thread

Alarmed-Face5680

2d ago

Thanks for this.. i originally just set up on opus and within an hour it shut down and tokens were gone.

I then set up on gpt 5.2 and been hit today after five days with a three day pause. So learning as a go as not a clue about any of this.

I’m struggling to understand what a “difficult” task maybe compared to an “easy” task. I’m seeing people do websites, apps etc. I’m not in for that.

This a productivity thing for me. What model do you think would work well for these?

1: KPI snapshot - crawls through Google docs, CRM system etc to pull together all the info I need in one place every morning.

2: compliance checks - checks through docs to ensure everything has been completed 3 x per week

3. Internet search / Property searches. Looking for new commercial premises each week.

4. CRM sweep. Contact been made in the right time frame to customers?

5. Content planning, proactive tasks aligned with goals and work towards those tasks before I get to them.

This is a few things I’ve either completed on openclaw already and working towards. But don’t want to get stuck each time on a zero tokens message. To me these are “easy” tasks in comparison to what I see others doing. But uncertain if they are or aren’t.

Could you let me know your thoughts please

3

1 more reply

Continue this thread

bezbol

1d ago

I spend two weeks searching for models and best api plans, solving issues everyday late into the night, setting up memories and recall, now she is the best thing ever, doing magic every day and never make mistakes. People know how to use claw is like jumping on a rocket ready to launch to an upper dimension, majority of people is still hesitant to hop on. The gap would be huge just in a blink of an eye!

3

NoRecognition3349

1d ago

Good on you for sticking with it. Nobody talks about the hours put in to set it up and refining it. They just show the end result which is why a lot of new people get frustrated with their agents and why they aren't on the moon yet. People who put in that time now to figure it out are going to be miles ahead. Glad it clicked for you brother!

3

Continue this thread

JesusXP

2d ago

I have a question, is it my experience only but I sometimes will have what appears to be no response at all. It will process endlessly until I ask it something else but essentially forgets what we are working on or what was the last ask, and sometimes the response it just one word or cut off and doesn’t seem to ever complete. Just weird and makes it tricky for me, I haven’t gotten any of the types of experiences I saw and what drew me in like the agentic looping on a given task, so I’ll work on the helpful suggestions and set up here, but the cut off responses seem to happen no matter the model even tho mostly z/ai glm is what I’m trying to take advantage of

2

7 more replies

Continue this thread

quietlikeblood

2d ago

I'm reusing an old computer, so I was happy to spend $100 on Opus credits really making sure everything is properly and fully set up to my liking. Now I'm now using GLM5 as my main driver and super happy with it. Opus is still invoked automatically when building or for more complex cron jobs.

2

2 more replies

Continue this thread

pedrobraz

2d ago

That’s awesome man thanks for sharing. Regarding your model tiering anything you could share? Like asking your agents to extract how they think about tiering and sharing that output? This is something I’ve been struggling with

2

1 more reply

Continue this thread

Comprehensive-Phase3

2d ago

Seems like this community knows a lot about OpenClaw and it just came out!

How do you recommend me to learn about it in-depth like you? I’m very interested but there’s a lot of information out there kinda repetitive

2

7 more replies

Continue this thread

NRWHH

2d ago

Thank you for this. I think I’ve written “figure out openclaw” on my to do list at least 3 separate times now lol, but this motivates me

2

2 more replies

Continue this thread

rhythmic_noises

2d ago

Can I add to your list?

If you're trying to run this using a local LLM, you also need to setup a local embedding model. The default options for the memory functions are expecting you to use OpenAI instead of a local embedding provider. I don't fully understand it, but I think if you don't have this setup, your system tries to send the entire damn workspace with every prompt.

I'm sure the docs explain it; but damn if I couldn't really follow them. It was trial and error for me.

https://docs.openclaw.ai/concepts/memory

I'm using a model called nomic-embed-text.

Maybe someone here that actually knows wtf they're doing (i.e. not me) can explain it. All I know: this is a night and day difference.

2

2 more replies

Continue this thread

---

## View Post in

Português (Brasil)

Français

Reddit Rules Privacy Policy User Agreement Your Privacy Choices Accessibility Reddit, Inc. © 2026. All rights reserved.


id: 7e9bc69a52f6
title: How are you making openclaw autonomous? : r/AI_Agents
source_url: https://www.reddit.com/r/AI_Agents/comments/1r6aa7e/how_are_you_making_openclaw_autonomous/
source_platform: reddit
author: unknown
published_at: 2026-03-11T01:00:09.094559+00:00
collected_at: 2026-03-11T01:00:50.366310+00:00
scenario_type: 工作流自动化
novelty: similar
similar_to_ids: ["93d2c2bcd5d9", "bfd43480fcf0", "6885ba6c5ca2"]
summary:
用户询问如何配置OpenClaw agent实现更高的自主性，社区讨论涉及启用连续执行模式、强制工具调用模式、持久化内存、任务队列系统和错误恢复策略等核心配置。该讨论针对AI agent自动化的关键技术瓶颈，具有实际工程价值，但主要围绕配置调优而非具体业务流程。

tools_used:
["OpenClaw", "Deepseek 3.2", "Minimax 2.1", "Gemini Flash", "Gemini Pro", "MCP Servers", "Memory Plugin", "Task Queue System"]

raw_content:
How are you making openclaw autonomous? : r/AI_Agents

How are you making openclaw autonomous? : r/AI_Agents Skip to main content How are you making openclaw autonomous? : r/AI_Agents

Go to AI_Agents

r/AI_Agents 22h ago

Dwarkas

# How are you making openclaw autonomous?

I keep seeing post about autonomous openclaw agents running entire comapnies and projects and stuff... Yet mine needs so much hand holding its annoying...

I'm using Deepseek 3.2 and Minimax 2.1 models.

What sort of config or settings did I miss or not enable? Please help. All YouTube guides are basic overview. Thanks

Share

---

• Promoted

Discover how 919 global leaders are prioritizing resilience, reliability & observability in the Dynatrace report.

---

ninadpathak

20h ago

That hand-holding is annoying. tried the same setup with deepseek and minimax last week and realized the tool_calling config was the culprit-had to force "tool_call" mode in the api params bc the default just ignores tools unless you beg. now it actually runs tasks without me hovering.

2

Dwarkas

18h ago

Thanks for the tip, I'm going to try this!

1

Continue this thread

ChatEngineer

18h ago

A few things that helped me get OpenClaw running more autonomously:

Enable continuous execution mode - In your config, set continuous: true and adjust the heartbeat interval (I use 300 seconds)

Tool calling setup - Like ninadpathak mentioned, force tool_call mode in API params. Also register your tools explicitly in the mcpServers config

Give it memory - The memory plugin lets it persist context across sessions - critical for long-running autonomy

Task registry - Use a task queue system so it can pick up work without you triggering each action

Error recovery - Set retry policies and fallback models. I run Gemini Flash for speed, with Pro as fallback for complex reasoning

The YouTube guides definitely gloss over the continuous execution config. Check the orchestrator docs - that's where the real autonomy lives.

What specific workflows are you trying to automate?

2

AutoModerator

22h ago

Thank you for your submission, for any questions regarding AI, please check out our wiki at https://www.reddit.com/r/ai_agents/wiki(this is currently in test and we are actively adding to the wiki)

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

1

penguinzb1

20h ago

the autonomy gap is real. most of what you see posted is either cherry-picked demos or people running agents on narrow, well-defined tasks. when you throw them at open-ended stuff, they fall apart quickly.

a few things that helped us:

better prompting around when to stop and ask vs when to push forward

logging every step so you can see where it goes off track

starting with smaller, more constrained tasks and gradually expanding scope

the model matters too. deepseek 3.2 is solid but tends to be overly cautious. you might get better autonomy with something more aggressive, but then you risk it making more mistakes.

what kind of tasks are you trying to get it to handle?

1

GarbageOk5505

12h ago

Honest take the model matters a lot more than people admit for autonomous workflows. DeepSeek 3.2 and Minimax 2.1 are decent for chat but they struggle with the kind of multi-step tool-use reasoning that makes an agent feel autonomous. They tend to lose track of what they've already done, repeat steps, or bail out and ask you instead of pushing through.

If you can swing it, try running it with Claude Sonnet or GPT-4o for the "planning" steps and keep the cheaper model for simple execution tasks. The difference is night and day for agentic loops. Also check your system prompt a lot of the YouTube setups leave out explicit instructions for how the agent should handle failures and retry on its own vs. asking you. That alone cuts the hand-holding significantly.

1

---

## View Post in

Português (Brasil)

Reddit Rules Privacy Policy User Agreement Your Privacy Choices Accessibility Reddit, Inc. © 2026. All rights reserved.


id: 77b4be38215d
title: ollama/ollama
summary: Ollama是一个Go语言开发的开源项目，提供本地LLM模型的快速部署和运行能力，支持多种开源大语言模型。通过CLI工具方式让用户在本地便捷地获取和运行各类AI模型，显著降低模型使用的技术门槛。
source_url: https://github.com/ollama/ollama
source_platform: github
author: ollama
published_at: 2026-03-10T22:53:27+00:00
collected_at: 2026-03-11T01:01:00.047342+00:00
scenario_type: 终端与CLI增强
tools_used: ["Ollama", "Kimi-K2.5", "GLM-5", "MiniMax", "DeepSeek", "Qwen", "Gemma", "Llama"]
novelty: similar
similar_to_ids: ["64e2a72bd549", "7c94eb734f17", "db0fc62f4243"]
raw_content:
ollama/ollama

Get up and running with Kimi-K2.5, GLM-5, MiniMax, DeepSeek, gpt-oss, Qwen, Gemma and other models.

Topics: deepseek, gemma, gemma3, glm, go, golang, gpt-oss, llama, llama3, llm, llms, minimax, mistral, ollama, qwen
Language: Go | Stars: 164782


id: 3d3ea81a8dfe
title: Launch HN: RunAnywhere (YC W26) – Faster AI Inference on Apple Silicon
source_url: https://github.com/RunanywhereAI/rcli
source_platform: hackernews
author: sanchitmonga22
published_at: 2026-03-10T17:14:52+00:00
collected_at: 2026-03-11T01:01:10.694418+00:00
scenario_type: 终端与CLI增强
tools_used: ["MetalRT", "RCLI", "Metal shaders", "Whisper", "Qwen3", "LFM2.5"]
novelty: similar
similar_to_ids: ["77b4be38215d", "64e2a72bd549", "7c94eb734f17"]
summary:
RunAnywhere推出MetalRT推理引擎和开源RCLI工具，为Apple Silicon设备提供极速的本地AI推理能力，支持LLM、语音识别和语音合成，性能超越llama.cpp和MLX等竞品。该方案通过自定义Metal着色器和零分配策略解决了语音AI管道中的延迟复合问题，实现完全离线、无需API密钥的端到端语音AI体验。

raw_content:
Launch HN: RunAnywhere (YC W26) – Faster AI Inference on Apple Silicon

Hi HN, we&#x27;re Sanchit and Shubham (YC W26). We built a fast inference engine for Apple Silicon. LLMs, speech-to-text, text-to-speech – MetalRT beats llama.cpp, Apple&#x27;s MLX, Ollama, and sherpa-onnx on every modality we tested. Custom Metal shaders, no framework overhead.<p>Also, we&#x27;ve open-sourced RCLI, the fastest end-to-end voice AI pipeline on Apple Silicon. Mic to spoken response, entirely on-device. No cloud, no API keys.<p>To get started:<p><pre><code>  brew tap RunanywhereAI&#x2F;rcli https:&#x2F;&#x2F;github.com&#x2F;RunanywhereAI&#x2F;RCLI.git
  brew install rcli
  rcli setup   # downloads ~1 GB of models
  rcli         # interactive mode with push-to-talk
</code></pre>
Or:<p><pre><code>  curl -fsSL https:&#x2F;&#x2F;raw.githubusercontent.com&#x2F;RunanywhereAI&#x2F;RCLI&#x2F;main&#x2F;install.sh | bash
</code></pre>
The numbers (M4 Max, 64 GB, reproducible via `rcli bench`):<p>LLM decode – 1.67x faster than llama.cpp, 1.19x faster than Apple MLX (same model files):
- Qwen3-0.6B: 658 tok&#x2F;s (vs mlx-lm 552, llama.cpp 295)
- Qwen3-4B: 186 tok&#x2F;s (vs mlx-lm 170, llama.cpp 87)
- LFM2.5-1.2B: 570 tok&#x2F;s (vs mlx-lm 509, llama.cpp 372)
- Time-to-first-token: 6.6 ms<p>STT – 70 seconds of audio transcribed in *101 ms*. That&#x27;s 714x real-time. 4.6x faster than mlx-whisper.<p>TTS – 178 ms synthesis. 2.8x faster than mlx-audio and sherpa-onnx.<p>We built this because demoing on-device AI is easy but shipping it is brutal. Voice is the hardest test: you&#x27;re chaining STT, LLM, and TTS sequentially, and if any stage is slow, the user feels it. Most teams fall back to cloud APIs not because local models are bad, but because local inference infrastructure is.<p>The thing that&#x27;s hard to solve is latency compounding. In a voice pipeline, you&#x27;re stacking three models in sequence. If each adds 200ms, you&#x27;re at 600ms before the user hears a word, and that feels broken. You can&#x27;t optimize one stage and call it done. Every stage needs to be fast, on one device, with no network round-trip to hide behind.<p>We went straight to Metal. Custom GPU compute shaders, all memory pre-allocated at init (zero allocations during inference), and one unified engine for all three modalities instead of stitching separate runtimes together.<p>MetalRT is the first engine to handle all three modalities natively on Apple Silicon. Full methodology:<p>LLM benchmarks: <a href="https:&#x2F;&#x2F;www.runanywhere.ai&#x2F;blog&#x2F;metalrt-fastest-llm-decode-engine-apple-silicon">https:&#x2F;&#x2F;www.runanywhere.ai&#x2F;blog&#x2F;metalrt-fastest-llm-decode-e...</a><p>Speech benchmarks: <a href="https:&#x2F;&#x2F;www.runanywhere.ai&#x2F;blog&#x2F;metalrt-speech-fastest-stt-tts-apple-silicon">https:&#x2F;&#x2F;www.runanywhere.ai&#x2F;blog&#x2F;metalrt-speech-fastest-stt-t...</a><p>How: Most inference engines add layers between you and the GPU: graph schedulers, runtime dispatchers, memory managers. MetalRT skips all of it. Custom Metal compute shaders for quantized matmul, attention, and activation - compiled ahead of time, dispatched directly.<p>Voice Pipeline optimizations details: <a href="https:&#x2F;&#x2F;www.runanywhere.ai&#x2F;blog&#x2F;fastvoice-on-device-voice-ai-pipeline-apple-silicon">https:&#x2F;&#x2F;www.runanywhere.ai&#x2F;blog&#x2F;fastvoice-on-device-voice-ai...</a>
RAG optimizations: <a href="https:&#x2F;&#x2F;www.runanywhere.ai&#x2F;blog&#x2F;fastvoice-rag-on-device-retrieval-augmented-voice-ai">https:&#x2F;&#x2F;www.runanywhere.ai&#x2F;blog&#x2F;fastvoice-rag-on-device-retr...</a><p>RCLI is the open-source voice pipeline (MIT) built on MetalRT: three concurrent threads with lock-free ring buffers, double-buffered TTS, 38 macOS actions by voice, local RAG (~4 ms over 5K+ chunks), 20 hot-swappable models, and a full-screen TUI with per-op latency readouts. Falls back to llama.cpp when MetalRT isn&#x27;t installed.<p>Source: <a href="https:&#x2F;&#x2F;github.com&#x2F;RunanywhereAI&#x2F;RCLI" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;RunanywhereAI&#x2F;RCLI</a> (MIT)<p>Demo: <a href="https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=eTYwkgNoaKg" rel="nofollow">https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=eTYwkgNoaKg</a><p>What would you build if on-device AI were genuinely as fast as cloud?


id: 034f0f8b6fff
title: How to make openclaw work on tasks for longer? : r/openclaw
summary: 用户询问如何让OpenClaw代理在复杂任务上工作更长时间以获得更好结果,而不是像普通LLM那样快速响应。社区建议使用心跳任务、技能链接和子代理来实现更深入的任务执行和多步骤工作流。
source_url: https://www.reddit.com/r/openclaw/comments/1rbvhai/how_to_make_openclaw_work_on_tasks_for_longer/
source_platform: reddit
author: unknown
published_at: 2026-03-11T01:00:09.094562+00:00
collected_at: 2026-03-11T01:01:19.602014+00:00
scenario_type: 工作流自动化
tools_used: ["OpenClaw", "ChatGPT OAuth", "Discord"]
novelty: similar
similar_to_ids: ["7e9bc69a52f6", "93d2c2bcd5d9"]
raw_content:
How to make openclaw work on tasks for longer? : r/openclaw

How to make openclaw work on tasks for longer? : r/openclaw Skip to main content How to make openclaw work on tasks for longer? : r/openclaw

Go to openclaw

r/openclaw 10d ago

chrisx221

# How to make openclaw work on tasks for longer?

Whatever complex task I give it, it responds almost immediately like any LLM would. Not sure how to make it agentic and work on a task for longer to get the expected result. Any tips for a newbie? I've tried what openclaw suggested "deep task mode" and similar prompts but I can't get it to work on a task longer than a minute. Using ChatGPT oAuth. Thanks in advance!

Read more

Share

---

• Promoted

Recevez 3x plus de candidatures qualifiées en promouvant vos offres d'emploi sur le plus grand réseau pro en France.

Collapse video player

---

AutoModerator

10d ago

Moderator Announcement Read More »

Hey there! Thanks for posting in r/OpenClaw.

A few quick reminders:

→ Check the FAQ- your question might already be answered → Use the right flair so others can find your post → Be respectful and follow the rules

Need faster help? Join the Discord.

Website: https://openclaw.ai Docs: https://docs.openclaw.ai ClawHub: https://www.clawhub.com GitHub: https://github.com/openclaw/openclaw

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

1

thebadslime

10d ago

You need to assign hearbeat tasks

2

stainless_steelcat

9d ago

Skills might be worth exploring as you can chain multiple prompts together eg research, draft, critique, final review etc.

1

ivanstackd

9d ago

Read this. I'm still working on it but sounds promising https://x.com/the_smart_ape/status/2025561622274883770?s=46&t=BypNtHhsf4SN7Dm6VsEIPg

1

_Zelus

7d ago

Wondering if you or OP have had any luck with this? I'm having two similar problems - one where it seems to be stopping on a big task and not delivering and one where I know it's supposed to be a long, deep-dive task and direct it to take it's time but it's returning results immediately that I don't think truly meet the parameters of the ask.

1

ivanstackd

7d ago

What happens with the big ask? Is it a timeout? I've had that with GLM where the agent freezes for minutes while it's "working" and then time outs. I would suggest to add to your Agents.md that it HAS to spawn sub-agents for any coding work

The deep dive tasks issue I have seen. A "deep-dive" is very different from person to person. You have to specify what you are looking for or use skills meant to "brainstorm". Another tip is use ChatGPT, to help you craft the prompt when you need something very specific

1

1 more reply

Continue this thread Continue this thread Continue this thread

ivanstackd

6d ago

I use discord only so I know exactly what you mean. The estimated times it gives you are always 95% off. My bot has said ETA 15 minutes and it finished 5 seconds later.

Couple things to check: what model are you using for heavy coding? I wouldn't do anything heavy without codex/sonnet/opus.

Also would ensure that your agents use subagents for all coding work, that way the agent can verify completion before reporting back and you will always be able to chat as the subagent works

1

[deleted]

10d ago

Comment removed by moderator

2

chrisx221

9d ago

Left it on default 5.3 codex

1

Continue this thread

Reddit Rules Privacy Policy User Agreement Accessibility Reddit, Inc. © 2026. All rights reserved.

Expand Navigation Collapse Navigation

Let us know your cookie preferences

Reddit uses cookies and similar technologies to:

- Monitor site usage and performance metrics
- Prevent fraud and abuse
- Keep the website operational and running properly
- Accessibility

If you choose “Accept All” we’ll also use cookies to:

- Develop and improve new features and services
- Measure the performance of ads
- Personalize your recommendations and ads

If you choose “Reject Optional Cookies” we won’t use cookies for these additional uses. You can update your cookie preference from your settings.

Learn more about how Reddit uses cookies.

Accept All Reject Optional Cookies


id: 665360c6c8e8
title: Show HN: The Mog Programming Language
source_url: https://moglang.org
source_platform: hackernews
author: belisarius222
published_at: 2026-03-09T17:57:00+00:00
collected_at: 2026-03-11T01:01:29.350825+00:00
scenario_type: 代码生成与审查
tools_used: ["Mog Programming Language", "Rust", "LLVM/Native Code Compilation", "dlopen()"]
novelty: similar
similar_to_ids: ["1e4478d8d921", "4b163a9dea20", "a90e1fa2514d"]
summary:
Mog是一种为AI代理设计的静态类型编译语言，具有极简语法（仅3200令牌）和基于能力的权限控制，使AI可以安全地生成、编译和动态加载自己的代码插件。该方案通过native编译和沙箱隔离解决了AI代理代码执行的安全性问题，但主要应用场景限于AI代理自扩展领域。

raw_content:
Show HN: The Mog Programming Language

Hi, Ted here, creator of Mog.<p>- Mog is a statically typed, compiled, embedded language (think statically typed Lua) designed to be written by LLMs -- the full spec fits in 3,200 tokens.
- An AI agent writes a Mog program, compiles it, and dynamically loads it as a plugin, script, or hook.
- The host controls exactly which functions a Mog program can call (capability-based permissions), so permissions propagate from agent to agent-written code.
- Compiled to native code for low-latency plugin execution -- no interpreter overhead, no JIT, no process startup cost.
- The compiler is written in safe Rust so the entire toolchain can be audited for security. Even without a full security audit, Mog is already useful for agents extending themselves with their own code.
- MIT licensed, contributions welcome.<p>Motivations for Mog:<p>1. Syntax Only an AI Could Love: Mog is written for AIs to write, so the spec fits easily in context (~3200 tokens), and it&#x27;s intended to minimize foot-guns to lower the error rate when generating Mog code. This is why Mog has no operator precedence: non-associative operations have to use parentheses, e.g.  (a + b) * c. It&#x27;s also why there&#x27;s no implicit type coercion, which I&#x27;ve found over the decades to be an annoying source of runtime bugs. There&#x27;s also less support in Mog for generics, and there&#x27;s absolutely no support for metaprogramming, macros, or syntactic abstraction.<p>When asking people to write code in a language, these restrictions could be onerous. But LLMs don&#x27;t care, and the less expressivity you trust them with, the better.<p>2. Capabilities-Based Permissionsl: There&#x27;s a paradox with existing security models for AI agents. If you give an agent like OpenClaw unfettered access to your data, that&#x27;s insecure and you&#x27;ll get pwned. But if you sandbox it, it can&#x27;t do most of what you want. Worse, if you run scripts the agent wrote, those scripts don&#x27;t inherit the permissions that constrain the agent&#x27;s own bash tool calls, which leads to pwnage and other chaos. And that&#x27;s not even assuming you run one of the many OpenClaw plugins with malware.<p>Mog tries to solve this by taking inspiration from embedded languages. It compiles all the way to machine code, ahead of time, but the compiler doesn&#x27;t output any dangerous code (at least it shouldn&#x27;t -- Mog is quite new, so that could still be buggy). This allows a host program, such as an AI agent, to generate Mog source code, compile it, and load it into itself using dlopen(), while maintaining security guarantees.<p>The main trick is that a Mog program on its own can&#x27;t do much. It has no direct access to syscalls, libc, or memory. It can basically call functions, do heap allocations (but only within the arena the host gives it), and return something. If the host wants the Mog program to be able to do I&#x2F;O, it has to supply the functions that the Mog program will call. A core invariant is that a Mog program should never be able to crash the host program, corrupt its state, or consume more resources than the host allows.<p>This allows the host to inspect the arguments to any potentially dangerous operation that the Mog program attempts, since it&#x27;s code that runs in the host. For example, a host agent could give a Mog program a function to run a bash command, then enforce its own session-level permissions on that command, even though the command was dynamically generated by a plugin that was written without prior knowledge of those permission settings.<p>(There are a couple other tricks that PL people might find interesting. One is that the host can limit the execution time of the guest program. It does this using cooperative interrupt polling, i.e. the compiler inserts runtime checks that check if the host has asked the guest to stop. This causes a roughly 10% drop in performance on extremely tight loops, which are the worst case. It could almost certainly be optimized.)<p>3.  Self Modification Without Restart: When I try to modify my OpenClaw from my phone, I have to restart the whole agent. Mog fixes this: an agent can compile and run new plugins without interrupting a session, which makes it dynamically responsive to user feedback (e.g., you tell it to always ask you before deleting a file and without any interruption it compiles and loads the code to... actually do that).<p>Async support is built into the language, by adapting LLVM&#x27;s coroutine lowering to our Rust port of the QBE compiler, which is what Mog uses for compilation. The Mog host library can be slotted into an async event loop (tested with Bun), so Mog async calls get scheduled seamlessly by the agent&#x27;s event loop.
Another trick is that the Mog program uses a stack inside the memory arena that the host provides for it to run in, rather than the system stack. The system tracks a guard page between the stack and heap. This design prevents stack overflow without runtime overhead.<p>Lots of work still needs to be done to make Mog a &quot;batteries-included&quot; experience like Python. Most of that work involves fleshing out a standard library to include things like JSON, CSV, Sqlite, and HTTP. One high-impact addition would be an `llm` library that allows the guest to make LLM calls through the agent, which should support multiple models and token budgeting, so the host could prevent the plugin from burning too many tokens.<p>I suspect we&#x27;ll also want to do more work to make the program lifecycle operations more ergonomic. And finally, there should be a more fully featured library for integrating a Mog host into an AI agent like OpenClaw or OpenAI&#x27;s Codex CLI.


id: 88a03457f4c8
title: WTH can I do useful with Openclaw? : r/AI_Agents
source_url: https://www.reddit.com/r/AI_Agents/comments/1r8bp5i/wth_can_i_do_useful_with_openclaw/
source_platform: reddit
author: unknown
published_at: 2026-03-11T01:00:09.094567+00:00
collected_at: 2026-03-11T01:01:39.427703+00:00
scenario_type: 工作流自动化
tools_used: ["OpenClaw", "arXiv", "PubMed", "bioRxiv", "Claude Code", "Opus"]
novelty: similar
similar_to_ids: ["034f0f8b6fff", "7e9bc69a52f6", "93d2c2bcd5d9", "d2fc47980430"]
summary:
讨论OpenClaw在STEM科研领域的实际应用，包括论文监测、数据管道自动化、文献综述和实验跟踪等任务。该工具的核心价值在于能够设置一次后持续自动运行，减少数据处理工作量，让科研人员专注于实际科学研究。

raw_content:
WTH can I do useful with Openclaw? : r/AI_Agents

WTH can I do useful with Openclaw? : r/AI_Agents Skip to main content WTH can I do useful with Openclaw? : r/AI_Agents

Go to AI_Agents

r/AI_Agents 2d ago

inComplete-Oven

# WTH can I do useful with Openclaw?

I'm not a dev but a stem scientist, so I write code but not software. I can't really come up with anything useful for Openclaw, apart from maybe installing software that's difficult to install. Everything else I can also do via the regular chat interfaces. Anybody with actually useful jobs for it that I can have it do?

Share

---

• Promoted

Developers & Codex 🩷 Try Codex for free with expanded limits.

---

Individual_Yard846

2d ago

if you cant find anything useful for Openclaw in your field, your not lazy enough bud.

39

ChatEngineer

2d ago

As a STEM scientist, here are some practical things I've automated with OpenClaw that go beyond what chat interfaces can do:

Research monitoring: It scans arXiv, PubMed, and bioRxiv for papers in my field, saves relevant ones, and emails me summaries weekly

Data pipeline automation: Connects lab instruments → data processing → cloud storage → analysis reports without manual steps

Literature reviews: Searches multiple databases, extracts key findings, and generates comparison tables

Experiment tracking: Monitors running simulations, alerts me when they complete, and logs results to a spreadsheet

The difference from chat interfaces is the autonomy - set it up once, it runs continuously. For a scientist, that means less time on data wrangling, more time on actual science.

Happy to share specific configs if any of these resonate with your work.

8

AdShoddy273

2d ago

That sounds amazing! My wife is doing phD in computational biology and she was looking for something like this. Can you please share more details on the configs and prompts of your openclaw cron jobs for summary emails?

1

IntelligentChance350

2d ago

Just run it through Opus to develop. Tell it you want to start small cron jobs in OpenClaw with a few identified research sources. Simple is better. There’s also a How I AI episode with Teresa Torres that goes into it a bit more if you’re setting up daily briefings etc.

2

Continue this thread 2 more replies

Continue this thread

Seakawn

2d ago

have it build an investigative framework that can run forensic querying on nearby business and local history of sales data to find where your dad is after he left for cigarettes when you were a child and never came back. it really works, I have already three promising leads and one seems like a match, I think it's him.

10

BenAttanasio

2d ago

Write a step by step guide on how to install Claude Code 😁

3

brikmaster

2d ago

Just ask Claude Code to do it. Works like a charm.

2

Continue this thread

• Promoted

Before you start with OpenClaw read this 132 page report. It can save you a lot of money, time and headaches.

grassxyz

2d ago

To answer your question the creator did unlock everything to let it to do anything that a human can do with a computer - research, programming , analyzing data , generating video but it comes a big cost& risk. All big tech put guardrails, firewall, sandbox in their boxes to ensure safety use. But OpenClaw remove all.

I did a technical analysis on openclaw so you don’t need to. Watch this and see if you still have want openclaw: If You Installed OpenClaw, Watch This Immediately https://youtu.be/MXo5CRqP5XI

-2

Investolas

1d ago

Risk equals liability for big tech

1

Continue this thread

secretBuffetHero

2d ago

are you a PhD scientist? have it do your research. have it do all the boring toil that you do not want to do yourself.

-3

inComplete-Oven

2d ago

It can't. It can't hardly shuffle into the lab and do experiments... Literature research etc. I can also do with the regular tools, that doesn't need agents.

8

secretBuffetHero

2d ago

I'm a former BS level lab bench chemist who did synthetic chemistry for organo-metallic catalysts used polyethylene synthesis and worked in the labs of a top public university as well as a materials science startup. I have a few patents and few publications, but not first author. So I have some idea of what I am talking about. I'm no MS or PhD, but I've been around.

The point is that you don't have to do the literature research all yourself. you can delegate that work. What if you have 10 interns doing that literature search for you? Think about all the time you could save if you didn't have to be on the computer as much. You could be at the bench more.

You could digitize all your lab notebooks and have it index and draw conclusions that it might difficult to draw on your own.

You could have it make reservations at your favorite restaurant. my understanding is that the creator did this, and when there were no reservations available, it downloaded text voice software, called the restaurant, and negotiated a reservation.

The more interesting question is not what can it do for you, but what can you do with it?

0

4 more replies

Continue this thread Continue this thread Continue this thread

AutoModerator

2d ago

Thank you for your submission, for any questions regarding AI, please check out our wiki at https://www.reddit.com/r/ai_agents/wiki(this is currently in test and we are actively adding to the wiki)

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

1

DaRandomStoner

2d ago

What would you want it to do? I don't use Openclaw personally but am building out agentic processes more broadly. I'm really curious what people like you might want in terms of automated systems with agentic ai built into them.

1

• Promoted

We're making MiniMax M2.5 free for a week

klingdiggs02

2d ago

It can make setting up your differential equations a whole lot faster

1

Josh2k24

2d ago

Anything. Your mind is the limiting factor

1

AncientFudge1984

2d ago

The Token IncineRator incinerates tokens. Got any tokens to incinerate?

1

Comfortable-Mud4040

2d ago

I feel sorry for you that your work involves you doing robotic tasks that can’t be automated so you can focus on what’s important

1

TySabs

2d ago

Have it give you daily news and weather summaries. Have it periodically scan your email for topics that you are particularly interested in and notify you with a summary if it gets a match.

Search for a quote on a home repair. Have it email 10 different contractors with pictures asking for a quote

1

raobjcovtn

2d ago

I use it to do work for my side gigs while I am at work for my real job. So I can send telegram commands to the agent from my phone while at work

1

Signal_Ad657

2d ago

So many crazy things, you could literally build an automated research lab with a GitHub and do some really wild experiments and cool work. Depends on what you do in STEM.

1

TheorySudden5996

2d ago

It’s a security nightmare so you should only run in an isolated sandbox.

1

DoctorDirtnasty

1d ago

ai will come for those without creativity and agency

1

---

## View Post in

Português (Brasil)

हिन्दी

Français

Reddit Rules Privacy Policy User Agreement Your Privacy Choices Accessibility Reddit, Inc. © 2026. All rights reserved.


id: abb1b9505bb9
title: Show HN: Mcp2cli – One CLI for every API, 96-99% fewer tokens than native MCP
source_url: https://github.com/knowsuchagency/mcp2cli
source_platform: hackernews
author: knowsuchagency
published_at: 2026-03-09T05:18:46+00:00
collected_at: 2026-03-11T01:01:48.895970+00:00
scenario_type: 终端与CLI增强
tools_used: ["mcp2cli", "MCP servers", "OpenAPI specs", "Claude Code", "Cursor"]
novelty: similar
similar_to_ids: ["ba31bde2dfc2", "faa318861b48"]
summary:
mcp2cli将任何MCP服务器或OpenAPI规范转换为运行时CLI，使LLM能按需发现工具，相比原生MCP方案在token消耗上减少96-99%。该工具无需代码生成或重建，与任何LLM兼容，并可作为AI代码代理的可安装技能使用，显著提高了LLM与API交互的效率。

raw_content:
Show HN: Mcp2cli – One CLI for every API, 96-99% fewer tokens than native MCP

Every MCP server injects its full tool schemas into context on every turn — 30 tools costs ~3,600 tokens&#x2F;turn whether the model uses them or not. Over 25 turns with 120 tools, that&#x27;s 362,000 tokens just for schemas.<p>mcp2cli turns any MCP server or OpenAPI spec into a CLI at runtime. The LLM discovers tools on demand:<p><pre><code>    mcp2cli --mcp https:&#x2F;&#x2F;mcp.example.com&#x2F;sse --list             # ~16 tokens&#x2F;tool
    mcp2cli --mcp https:&#x2F;&#x2F;mcp.example.com&#x2F;sse create-task --help  # ~120 tokens, once
    mcp2cli --mcp https:&#x2F;&#x2F;mcp.example.com&#x2F;sse create-task --title &quot;Fix bug&quot;
</code></pre>
No codegen, no rebuild when the server changes. Works with any LLM — it&#x27;s just a CLI the model shells out to. Also handles OpenAPI specs (JSON&#x2F;YAML, local or remote) with the same interface.<p>Token savings are real, measured with cl100k_base: 96% for 30 tools over 15 turns, 99% for 120 tools over 25 turns.<p>It also ships as an installable skill for AI coding agents (Claude Code, Cursor, Codex): `npx skills add knowsuchagency&#x2F;mcp2cli --skill mcp2cli`<p>Inspired by Kagan Yilmaz&#x27;s CLI vs MCP analysis and CLIHub.<p><a href="https:&#x2F;&#x2F;github.com&#x2F;knowsuchagency&#x2F;mcp2cli" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;knowsuchagency&#x2F;mcp2cli</a>


id: ba12b3f18777
title: Show HN: DenchClaw – Local CRM on Top of OpenClaw
source_url: https://github.com/DenchHQ/DenchClaw
source_platform: hackernews
author: kumar_abhirup
published_at: 2026-03-09T14:55:42+00:00
collected_at: 2026-03-11T01:02:14.199156+00:00
scenario_type: 本地数据集成
tools_used: ["OpenClaw", "DuckDB", "Telegram", "DenchClaw CLI"]
novelty: similar
similar_to_ids: ["e4f7d4fe231b", "39d6b08b7043", "85b23a6c94bb"]
summary:
DenchClaw是一个开源的本地CRM框架，基于OpenClaw和DuckDB构建，允许用户通过CLI在本地管理客户关系数据。该项目将OpenClaw的强大功能与易用的CRM工作流相结合，支持自然语言查询、多视图展示和Telegram集成，为个人和权力用户提供完全本地化的、无需云服务的解决方案。

raw_content:
Show HN: DenchClaw – Local CRM on Top of OpenClaw

Hi everyone, I am Kumar, co-founder of Dench (<a href="https:&#x2F;&#x2F;denchclaw.com" rel="nofollow">https:&#x2F;&#x2F;denchclaw.com</a>). We were part of YC S24, an agentic workflow company that previously worked with sales floors automating niche enterprise tasks such as outbound calling, legal intake, etc.<p>Building consumer &#x2F; power-user software always gave me more joy than FDEing into an enterprise. It did not give me joy to manually add AI tools to a cloud harness for every small new thing, at least not as much as completely local software that is open source and has all the powers of OpenClaw (I can now talk to my CRM on Telegram!).<p>A week ago, we launched Ironclaw, an Open Source OpenClaw CRM Framework (<a href="https:&#x2F;&#x2F;x.com&#x2F;garrytan&#x2F;status&#x2F;2023518514120937672?s=20" rel="nofollow">https:&#x2F;&#x2F;x.com&#x2F;garrytan&#x2F;status&#x2F;2023518514120937672?s=20</a>) but people confused us with NearAI’s Ironclaw, so we changed our name to DenchClaw (<a href="https:&#x2F;&#x2F;denchclaw.com" rel="nofollow">https:&#x2F;&#x2F;denchclaw.com</a>).<p>OpenClaw today feels like early React: the primitive is incredibly powerful, but the patterns are still forming, and everyone is piecing together their own way to actually use it. What made React explode was the emergence of frameworks like Gatsby and Next.js that turned raw capability into something opinionated, repeatable, and easy to adopt.<p>That is how we think about DenchClaw. We are trying to make it one of the clearest, most practical, and most complete ways to use OpenClaw in the real world.<p>Demo: <a href="https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=pfACTbc3Bh4#t=43" rel="nofollow">https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=pfACTbc3Bh4#t=43</a><p><pre><code>  npx denchclaw
</code></pre>
I use DenchClaw daily for almost everything I do. It also works as a coding agent like Cursor - DenchClaw built DenchClaw. I am addicted now that I can ask it, “hey in the companies table only show me the ones who have more than 5 employees” and it updates it live than me having to manually add a filter.<p>On Dench, everything sits in a file system, the table filters, views, column toggles, calendar&#x2F;gantt views, etc, so OpenClaw can directly work with it using Dench’s CRM skill.<p>The CRM is built on top of DuckDB, the smallest, most performant and at the same time also feature rich database we could find. Thank you DuckDB team!<p>It creates a new OpenClaw profile called “dench”, and opens a new OpenClaw Gateway… that means you can run all your usual openclaw commands by just prefixing every command with `openclaw --profile dench` . It will start your gateway on port 19001 range. You will be able to access the DenchClaw frontend at localhost:3100. Once you open it on Safari, just add it to your Dock to use it as a PWA.<p>Think of it as Cursor for your Mac (also works on Linux and Windows) which is based on OpenClaw. DenchClaw has a file tree view for you to use it as an elevated finder tool to do anything on your mac. I use it to create slides, do linkedin outreach using MY browser.<p>DenchClaw finds your Chrome Profile and copies it fully into its own, so you won’t have to log in into all your websites again. DenchClaw sees what you see, does what you do. It’s an everything app, that sits locally on your mac.<p>Just ask it “hey import my notion”, “hey import everything from my hubspot”, and it will literally go into your browser, export all objects and documents and put it in its own workspace that you can use.<p>We would love you all to break it, stress test its CRM capabilities, how it streams subagents for lead enrichment, hook it into your Apollo, Gmail, Notion and everything there is. Looking forward to comments&#x2F;feedback!


id: 51d6155061d6
title: lobehub/lobehub
summary: LobeHub是一个多智能体协作平台,支持多个AI模型集成和智能体团队设计,用于工作流自动化和团队协作。该项目通过MCP等技术实现智能体之间的无缝协作,提高团队工作效率。
source_url: https://github.com/lobehub/lobehub
source_platform: github
author: lobehub
published_at: 2026-03-11T00:38:51+00:00
collected_at: 2026-03-11T01:02:39.265781+00:00
scenario_type: 工作流自动化
tools_used: ["lobehub", "ChatGPT", "Claude", "DeepSeek", "Gemini", "GPT", "OpenAI", "MCP"]
novelty: similar
similar_to_ids: ["cebb6abe12ab", "6885ba6c5ca2", "5471379ee4ff", "97dcab4759c8", "a44c7aa65560"]
raw_content:
lobehub/lobehub

The ultimate space for work and life — to find, build, and collaborate with agent teammates that grow with you. We are taking agent harness to the next level — enabling multi-agent collaboration, effortless agent team design, and introducing agents as the unit of work interaction.

Topics: agent, agent-collaboration, agent-harness, ai, chatgpt, claude, deepseek, gemini, gpt, knowledge-base, mcp, openai
Language: TypeScript | Stars: 73405


id: b2c80ce8e19d
title: OpenAI just hired the OpenClaw creator : r/ArtificialInteligence
source_platform: reddit
author: unknown
published_at: 2026-03-11T01:00:09.094586+00:00
collected_at: 2026-03-11T01:02:58.594394+00:00
scenario_type: 工作流自动化
tools_used: ["OpenClaw", "ExoClaw", "WhatsApp", "Telegram", "Slack", "HAProxy"]
novelty: similar
similar_to_ids: ["88a03457f4c8", "034f0f8b6fff", "7e9bc69a52f6", "93d2c2bcd5d9"]
summary:
讨论OpenAI聘请OpenClaw创始人领导个人代理部门的消息，OpenClaw是一款开源AI助手，可自主处理邮件、网页浏览、代码执行和日程管理等任务。用户分享了使用ExoClaw托管版本的实际体验，包括邮件分类、线索监控和周报生成等工作流自动化应用，但也存在安全隐患需要关注。

source_url:
https://www.reddit.com/r/ArtificialInteligence/comments/1r6xixe/openai_just_hired_the_openclaw_creator/

raw_content:
OpenAI just hired the OpenClaw creator : r/ArtificialInteligence

OpenAI just hired the OpenClaw creator : r/ArtificialInteligence Skip to main content OpenAI just hired the OpenClaw creator : r/ArtificialInteligence

Go to ArtificialInteligence

r/ArtificialInteligence 13h ago

Deep_Ladder_4679

# OpenAI just hired the OpenClaw creator

So the guy who built OpenClaw, originally called Clawdbot because it was literally named after Anthropic's Claude, just got hired by OpenAI. Not Anthropic. OpenAI. You can't make this stuff up.

For those out of the loop: OpenClaw is that open-source AI assistant that actually DOES things instead of just talking about doing things. You run it on a Mac Mini or whatever, connect it to your WhatsApp/Telegram/Slack, and it handles your emails, browses the web, runs code, manages your calendar, all autonomously. It even has a "heartbeat" where it wakes up on its own and checks on stuff without you asking.

The project went from like 9k to 145k+ GitHub stars in weeks. Caused actual Mac Mini shortages. Jason Calacanis says his company offloaded 20% of tasks to it in 20 days and doesn't plan to hire humans for a year.

Peter Steinberger (the creator) is now leading OpenAI's "personal agents" division. OpenClaw stays open source under a foundation. Both Meta and OpenAI were fighting over him, apparently.

The security concerns are real, though, Cisco found third-party skills doing data exfiltration without users knowing. One of OpenClaw's own maintainers said if you can't use a command line, this project is too dangerous for you, lol.

But yeah. We're officially in the "AI agents that do stuff" era now. Chatbots feel like last year already.

Anyone here actually running OpenClaw? What's your setup?

Read more

Share

---

• Promoted

How to properly secure OpenClaw with HAProxy

---

AutoModerator

13h ago

Moderator Announcement Read More »

1

ImDonaldDunn

12h ago

This will end well lmao

22

Deep_Ladder_4679

12h ago

No, it will be open source continuous, but OpenAI is planning to do something in this space

-5

Continue this thread

NeedleworkerSmart486

13h ago

Been running it through ExoClaw (managed hosting) for a few months now and its honestly the most useful AI setup Ive tried. The heartbeat thing is what makes it feel completely different from ChatGPT or Claude, it just does stuff on its own without me prompting it every time. I have it handling email triage, lead monitoring, and weekly reports. Curious what happens to the project now that hes at OpenAI though. The foundation thing sounds promising but weve seen how that goes with other open source projects.

16

TheGuy839

6h ago

I cant find a single useful thing for them. If i need to send emails, I need to read emails and I can just as well send it to ai myself. What is lead monitoring? Most monitorings there dedicated monitoring tools? Weekly reports? Of what? You already get email weekly reports in many environments.

Seems just "independent" hype without any real monetary value. And I speak this as Senior ML engineer

4

Pinoybl

12h ago

Can you explain what lead monitoring is?

3

RyTheSkyGuy

13h ago

As long as the foundation sees to it so that it works how it always has. Don't fix what ain't broke.

1

Downtown_Finance_661

10h ago

So you dont have mac mini yourself? What OS are your workstation under?

1

Continue this thread

• Promoted

Learn in-demand Python skills from Microsoft and become a job-ready developer in less than 4 months.

smx501

7h ago

OpenAI is purchasing the publicity. There is nothing unique about OpenClaw or its creator.

The YouTubers claiming they have teams of Openclaw agents running their lives are lying.

9

Deep_Ladder_4679

7h ago

Please check your facts. It is already all over the place

-8

smx501

7h ago

Doing what, again?

3

1 more reply

Continue this thread Continue this thread Continue this thread

empty-alt

13h ago

Just set up openclaw the other night. I only just got it to the point where I'm happy with the infra of my setup. I'm think tomorrow I'm going to go down the rabbit hole of integrating something more impressive than search. Maybe notion, or google calendars, I'm not sure. I burned through some sonnet tokens today, so I took a look at open router to get access to some cheaper models.

It's been cool to play around with. I did it through Digital Ocean's 1-click deploy and hid it behind a VPN and firewalled all inbound traffic. The 1-click deploy also runs openclaw in sandboxed mode which is nice. Basically, it can't just run arbitrary commands, it needs to use the native tools, and it has very limited access to the directories. I'm shocked that both DO and Railway's 1-click deploys have the ControlUI on the open internet by default. Seems a little sketch to me. Makes me wonder how many are out there being bit by bots right now.

7

ktaraszk

7h ago

Yeah the exposed control UI thing is wild. I've seen instances indexed by Shodan with literally zero auth. The sandboxed mode helps but doesn't fix the authentication problem.

If you're burning through tokens fast, definitely check out the Gemini models on OpenRouter. Flash 1.5 is stupid cheap and pretty capable for most agent tasks. Claude's still better for complex reasoning but you can route selectively based on task.

For integrations, the Google Calendar one is surprisingly useful if you let it actually manage your schedule. Notion can get messy fast though, the API rate limits are annoying and the data model doesn't always play nice with agent workflows.

1

Continue this thread

OscarElmahdy

10h ago

Who needs complicated mumbo jumbo when you can just give AI the nuclear codes

4

mpw-linux

2h ago

Maybe AI already has the nuclear codes. We can have OpenClaw running NORAD as well !

1

Continue this thread

Pro_Automation__

13h ago

Big step AI agents are moving beyond chat and starting to handle real work in daily tasks.

1

TheGuy839

6h ago

Which tasks exactly?

3

k2h1982

56m ago

Just installed it 2 days ago and I can confirm that it can do actual things. For instance, 5 mins ago, i sent him a screenshot of spotify with a podcast i just listened. Asked him to find me the transcript, do a summary and create a note on my note tool (mem.ai). He did that in less than one minute, after trying different methods to retrieve the summary, including looking for a YT video. He finally found an audio of the podcast on podbean, downloaded it, figured out a way to convert a mpeg into text (by dowloading and using a tool from openai called whisper something). He did the summary and created a new note (yesterday, it successfuly connected to my note tool). All in less that one minute. For the record, i tried chatgpt or claude or gemini the exact same workflow, months ago, and after multiple prompts, i didnt manage to do it. Here, with the Openclaw agent, it managed to do what i wanted and i didnt see one single line of code.

1

Continue this thread Continue this thread

• Promoted

Users will never stop asking for more integrations, but integrations costs months of engineering (API research, building auth, error handling etc.). 29% of B2B SaaS engineering teams use an embedded iPaaS - to save 70% of the engineering, but should you? Read the detailed build vs. buy comparison.

subkubli

11h ago

Security is one thing, costs of agents, token consumption makes that idea not very promising. It may work to some extent but cost if it is too high to become popular, especially that llm's hallucinations is something that can't be solved.

1

LatentSpaceLeaper

3h ago

Only that "just" was two days ago which is equivalent to 14 days / two weeks on the AI time scale.

1

i_wish_i_was_perez

7h ago

«You can make this up»

Dude is model agnostic, he uses the latest and greatest - proven through his blog and X. If 5.3 had come before Opus it would probably have a different name.

0

keyhanimo

13h ago

Seeing things go crazy with examples of OpenClaw agents going rogue prompted me to think about what it means that software can now exercise its own judgment, as opposed to what software used to be: instructions for rule following that were followed to the letter. Wrote a full blog post on it here: https://www.digitvibe.com/ai-agents-and-the-rise-of-judgment-powered-software/

-4

---

## View Post in

हिन्दी

Reddit Rules Privacy Policy User Agreement Your Privacy Choices Accessibility Reddit, Inc. © 2026. All rights reserved.


id: 1de940123469
title: Show HN: VS Code Agent Kanban: Task Management for the AI-Assisted Developer
source_platform: hackernews
author: gbro3n
published_at: 2026-03-09T10:28:08+00:00
collected_at: 2026-03-11T01:03:11.745414+00:00
scenario_type: 终端与CLI增强
tools_used: ["VS Code", "Kanban Board", "GitOps", "Agent Commands", "Markdown"]
novelty: similar
similar_to_ids: ["853c63f738f0", "3fff252b35ec", "257ed0953657"]
summary:
这是一个VS Code集成的Kanban任务管理扩展，专为AI辅助开发者设计，通过@kanban命令提供结构化的计划/待办/实现流程，同时以Markdown格式维护持久化的任务记录以抵抗上下文衰减。该方案与现有Agent框架紧密配合，提高了开发工作流的组织效率和团队协作能力。

source_url:
https://www.appsoftware.com/blog/introducing-vs-code-agent-kanban-task-management-for-the-ai-assisted-developer

raw_content:
Show HN: VS Code Agent Kanban: Task Management for the AI-Assisted Developer

Agent Kanban has 4 main features:<p>GitOps &amp; team friendly kanban board integration inside VS Code
Structured plan &#x2F; todo &#x2F; implement via @kanban commands
Leverages your existing agent harness rather than trying to bundle a built in one
.md task format provides a permanent (editable) source of truth including considerations, decisions and actions, that is resistant to context rot


id: 19e007cf2bb9
title: Question: What is your AI coding workflow? : r/vibecoding
source_url: https://www.reddit.com/r/vibecoding/comments/1jczeqq/question_what_is_your_ai_coding_workflow/
source_platform: reddit
author: Corvoxcx
published_at: 2026-03-11T01:00:10.288386+00:00
collected_at: 2026-03-11T01:03:26.597811+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude", "MCP", "Aider", "Repomix", "Ollama", "OpenAI Responses API", "Local Models"]
novelty: similar
similar_to_ids: ["4e8f450b17be", "c4c047193758", "bf5997aa698e", "f7abc3c22065"]
summary:
讨论了AI辅助编码工作流程，包括架构规划、代码生成和调试。用户分享了使用本地模型（Ollama）、多智能体系统以及结构化提示管理（ai_guidelines.md和ai_output.md）来优化开发效率的经验，强调了保持对AI输出的监督和持续学习的重要性。

raw_content:
Question: What is your AI coding workflow? : r/vibecoding


 Question: What is your AI coding workflow? 
 Author: Corvoxcx 
 Time Posted (UTC): 2025-03-16 23:54:13+00:00 
 Score: 18 
 


 
 Link: https://www.reddit.com/r/vibecoding/comments/1jczeqq/question_what_is_your_ai_coding_workflow/ 
 


 
 Hey folks, Main Question: What is your AI coding workflow? I’m looking to better understand how you all are implementing AI into your coding work so I can add to my own approach. Currently I use LLMS for brainstorming, boiler plate code and debugging 
 


 
 Comments 
 


 
 
 Comment by: beaker_dude
 | Posted (UTC): 2025-03-17
 | Score: 5
 
 Right now my workflow is : create an architectural plan, use MCP and Claude code to execute, fix bugs. Aider and Repomix are highly used tools too. 


 
 
 Comment by: Corvoxcx
 | Posted (UTC): 2025-03-17
 | Score: 2
 
 Are you generating this architectural plan and inputting into an LLM in a particular format? Are you using an LLM for genera the architecture plans as well? 


 
 
 Comment by: KonradFreeman
 | Posted (UTC): 2025-03-17
 | Score: 4
 
 One way to keep AI interactions organized is by creating an ai\_guidelines.md file to track logic and an ai\_output.md ledger to monitor changes. This helps maintain context rather than seeing isolated edits. The key is learning from AI’s output, refining your own skills to eventually surpass it—though I’ll admit, it’s often more capable than me. I got into local models because I didn’t want to pay for API calls every time I tested something. Installing Ollama changed everything—it sped up my workflow and made upgrading my laptop worth it, especially with the newer MacBooks’ unified memory for handling larger models. I also built a system that functions like an entire tech company, with agents handling architecture, backend, frontend, testing, UX/UI, DevOps, security, and CI/CD—all managed by an orchestrator agent. Each agent gets a system prompt, and user prompts flow through with metadata. I adapted OpenAI’s Responses API logic, which they use for their Agents SDK, to work with Ollama instead. Rather than relying on their API, I structured it locally, passing prompts, context, and ai\_guidelines.md updates dynamically between agents. The trick is keeping an eye on how the AI modifies its own guidelines—letting it adapt is great, but if you don’t monitor it, things can go off the rails fast. That’s why you always read everything you vibe code. https://preview.redd.it/g40l1iwpv5pe1.jpeg?width=2938&format=pjpg&auto=webp&s=660b2c7d1dc03c863a1fa8d621abb230bd1d9573 


 
 
 Comment by: Corvoxcx
 | Posted (UTC): 2025-03-18
 | Score: 2
 
 "I also built a system that functions like an entire tech company, with agents handling architecture, backend, frontend, testing, UX/UI, DevOps, security, and CI/CD—all managed by an orchestrator agent. Each agent gets a system prompt, and user prompts flow through with metadata. I adapted OpenAI’s Responses API logic, which they use for their Agents SDK, to work with Ollama instead. Rather than relying on their API, I structured it locally, passing prompts, context, and ai\_guidelines.md updates dynamically between agents." This is amazing. Dude I'd pay you to teach me this setup 


 
 
 Comment by: KonradFreeman
 | Posted (UTC): 2025-03-18
 | Score: 3
 
 The repo Orchestrator-Ollama isn’t a finished product—it was a way for me to teach myself concepts. That’s my process: I don’t finish repos, I learn as much as I can and move on. This one helped me explore **graph-based AI orchestration** using networkx to define agent flow. Nodes represent agents, and edges represent prompts, context, metadata, vector stores, and now **MCP**. It’s basic—not meant to impress, just for learning. Lately, I’ve been working on **ai\_guidelines.md**, inspired by the standardized guidelines from big tech data annotation jobs. I want to build a **UI for adjusting coding principles dynamically**, but I also want to take it further: • Build a **graph mapping every aspect of a tech company**, including all job roles. • Individually define **prompts for each role** using **f-strings**. • Store prompts in a **database (JSON, SQLite, etc.)** for dynamic updates via a frontend. • Enable **A/B testing, RLHF**, and optimization. • Structure **few-shot prompts** with contextual edges linking system prompt nodes. For the **hackathon**, I’m integrating this repo with an **MCP server** I’m coding to work with Ollama. I also realized I still have **PDFs of annotation guidelines** from various companies—I could use **RAG** to reference them and **few-shot my own ai\_guidelines.md**. That’s a great idea. I could do that with my **Simulacra App**—the one I have to hide from *Zuck’s Robot Jesus*. But in the end, it’ll be a **persona-based reasoning agent** that can **call functions using MCP** to execute tasks like browser automation. Honestly, that’s probably all **Manus** is—just kidding. 😆 No need to pay me—I’ll teach you for free. I publish everything I make on my website: **danielkliewer.com**, and you can follow me on GitHub: **github.com/kliewerdaniel**. Also, fun fact: I technically work for Meta right now as a **third-party annotator**, but I set my own schedule and didn’t work for them at all last month. I’ve worked for other tech companies too—pretty sure Anthropic was the contract that got me out of poverty. https://preview.redd.it/f9hrcl7hmdpe1.png?width=971&format=png&auto=webp&s=55a09c6c77c07402844d2d59c1386b0ac202f85f 

 
 

 
 
 Comment by: Corvoxcx
 | Posted (UTC): 2025-03-18
 | Score: 1
 
 Thanks for these details. Much obliged. 

 

 
 
 Comment by: Corvoxcx
 | Posted (UTC): 2025-03-18
 | Score: 1
 
 Out of curiosity could you point me towards any references that could help me setup some local LLMS? When comparing the local LLMS vs a deployed LLM do you notice any differences. I'd love to cut costs. 


 
 
 Comment by: KonradFreeman
 | Posted (UTC): 2025-03-18
 | Score: 1
 
 Local models vs. APIs is night and day—APIs come with rate limits, token caps, and ever-changing SDKs, while local models give you full control over token counts, latency, privacy, and offline access. I started using Ollama to cut API costs, and it just works. The trade-off? Quality. SOTA models run on absurdly expensive hardware, while local models lag behind. Even with my M4 Pro MacBook (48GB RAM), I can’t match API performance—deepseek-r1:70b eats 42GB, mistral-small:24b takes 25GB. My PersonaGen tool worked fine with OpenAI but broke locally due to parameter limits. To fix that, I built a reasoning graph (basically a glorified for loop). Now, I’m working on MCP and JSON-constrained output since local models struggle there. If you’re into this, r/LocalLLaMA is a great community. Outside AI, I’ve lived a life—8 years in and out of transitional housing, now working manual labor while walking 4 miles a day. Studied OCW MIT daily for 4 years straight. Spent a decade in data annotation, back when you could Turk for $20 in 30 minutes. Not the best coder, but I get how AI works end to end. Just trying to break into AI dev. Again I had to summarize this one, twice, in order for it to fit with the LLM, sorry. https://preview.redd.it/zpiej65wddpe1.jpeg?width=3024&format=pjpg&auto=webp&s=cc606e3e1dc0a4f72b82a13dc378706658c277f1 Haha, this one looks AI generated, but it was really just bad photoshopping on my phone, I made these on my phone everyday while I was studying ocw.mit.edu like it was my job as part of my routine. 


 
 
 Comment by: sneakpeekbot
 | Posted (UTC): 2025-03-18
 | Score: 1
 
 Here's a sneak peek of /r/LocalLLaMA using the top posts of all time! \#1: Bro whaaaat? | 360 comments \#2: Grok's think mode leaks system prompt | 528 comments \#3: Starting next week, DeepSeek will open-source 5 repos | 312 comments ---- ^^I'm ^^a ^^bot, ^^beep ^^boop ^^| ^^Downvote ^^to ^^remove ^^| ^^Contact ^^| ^^Info ^^| ^^Opt-out ^^| ^^GitHub 

 
 
 
 
 
 

 
 
 Comment by: witmann_pl
 | Posted (UTC): 2025-03-17
 | Score: 3
 
 I start projects by setting up a Github repo for them. Then I discuss the project with chatgpt and we come up with a detailed development plan. I save this development in a markdown document (like development_plan.md) which I put into the project folder. This plan includes frameworks I want to use and some architecture details important when building the scaffolding of the app. Next I ask gpt to create a detailed, step-by-step description of the first tasks from the development plan. I paste this into a todo.md file in the project folder. In Cursor I ask it to read the development_plan.md and to follow the steps inside todo.md. I review the generated code after each step. After the steps from the todo.md are implemented I ask Augment Code to write a new todo.md file for the next steps. Augment is good at reading existing codebase. I use the free version as I'm OK with them using my code for model training. When the new todo.md is ready, I ask Cursor to follow it. Rinse and repeat. 


 
 
 Comment by: Corvoxcx
 | Posted (UTC): 2025-03-18
 | Score: 1
 
 Thanks! 

 
 

 
 
 Comment by: ipranayjoshi
 | Posted (UTC): 2025-03-17
 | Score: 2
 
 Here’s mine, but keep in mind that I have years of programming experience so this is more from that point of view. I start, generally, with either a template of a project that I have created myself or by picking up a template from the community. For example, for NextJS. Then I open it up in cursor where I have set a few very simple rules - for example, certain libraries that I usually go for. Cursor agents are really good now! So it’s pretty much using cursor agent to build out one tiny feature at a time. When it comes to breaking up my features, I start with the design of a page, then go into sections in the page. So basically I nail down the design to get a sense of what I expect the user experience to be like. And then, finally, I go into building out the backend / service side code and architecting the database tables based on the user experience that I have already thought through while building the page. 


 
 
 Comment by: Corvoxcx
 | Posted (UTC): 2025-03-18
 | Score: 1
 
 Thanks for this info. 

 

 
 
 Comment by: GibsonAI
 | Posted (UTC): 2025-03-21
 | Score: 1
 
 Interesting that you start with the front end and then build the corresponding backend. Some build the backend iteratively as they go. Do you build the DB with any tools or do you spin that up by hand? 


 
 
 Comment by: ipranayjoshi
 | Posted (UTC): 2025-03-21
 | Score: 1
 
 I just ask cursor to build it as I go. I’m using drizzle for schema, so it just has to update that file and then I can run the migration to implement the changes on the db 


 
 
 Comment by: GibsonAI
 | Posted (UTC): 2025-03-21
 | Score: 1
 
 Got it. Thanks! 

 
 
 
 

 
 
 Comment by: Any-Blacksmith-2054
 | Posted (UTC): 2025-03-17
 | Score: 2
 
 I copy my boilerplate and start brainstorm - generate cycle. Also, run agents for product owner, BA and marketing. Then buy new domain and fix CI/CD to my VPS 

 

 
 
 Comment by: KonradFreeman
 | Posted (UTC): 2025-03-17
 | Score: 1
 
 My workflow is constantly evolving as I learn and adapt. I enter a flow state through reading and writing, using my computer to stop overthinking. Then, I remember my project—**Simulacra**—which aims to reconstruct personalities and create interactive agents, essentially resurrecting people like my late friend Chris. https://preview.redd.it/sswgzjtp46pe1.jpeg?width=1440&format=pjpg&auto=webp&s=0cf1f60c15b4fcce757603f660683eeb257d8fc9 I built **PersonaGen**, a modular system that stores persona data in JSON, manipulated via a **Vite frontend** for visualization, heuristics, and agent construction. My process begins with **brainstorming** using free models like **4o or Llama3.2**, iterating prompts until I create a **table of contents-style dissertation**. Each chapter contains prompts and outputs, tested recursively to refine code. The dissertation outlines tech choices, references, and a **system prompt** that defines AI agents, including an orchestrator to manage workflows. I prefer **Sonnet3.7** for reasoning, as it allows console-based tuning. Once the dissertation generates **ai\_guidelines.md** and **ai\_output.md**, I feed them into **Cline, Twinny, and** **Continue.Dev** for iterative coding within **VSCode**. Recursive LLM calls summarize and refine outputs, conserving tokens while maintaining context. I also want to try out v0.dev to try to generate or find a frontend to use, like maybe design something in figma and feed it to that and then take the typescript into Cline and have it implement it for me. Once tested, I document everything with an LLM, manually editing for clarity. I then blog about it, post on **Reddit**, and use feedback to improve the next iteration—like my **Simulacra app**. Sorry for the LLM response, my first response was just too long so I had to have it summarized, haha. 


 
 
 Comment by: Corvoxcx
 | Posted (UTC): 2025-03-18
 | Score: 1
 
 Lol no prob. Thanks! 

 
 

 
 
 Comment by: oruga_AI
 | Posted (UTC): 2025-03-17
 | Score: 1
 
 I do a project planning on o3 m h then pass it trough gpt to generate deep research for tech updates on the tech stack. Then pass all the info trough a project to get. 1 the ui 2 the ux 3 (this is something non tech but helps the agents a lot) a user pov step by step on how to use the app 4 (complements the one above) a backend description on how is build each step of the pov 5 descriptions on how to build the ui/ux on html and css some times js desc 6 rules file on how to use the arc 7 changes log file 8 current bug file From there start vibing 


 
 
 Comment by: Corvoxcx
 | Posted (UTC): 2025-03-18
 | Score: 1
 
 Thanks for the tips 

 
 

 
 
 Comment by: ShelbulaDotCom
 | Posted (UTC): 2025-03-17
 | Score: 1
 
 Shirt. No pants. Lincoln hat. Monocle. MacBook air. Cheeseburger. But, Shelbula for the coding itself. Iterate in a dedicated environment for coding with the ability to create custom bots for any programming task, as well as use any AI model from the big 3. Follows the belief of keeping your production code in a bubble. Iterate first, bring clean code to your IDE of choice. 


 
 
 Comment by: Corvoxcx
 | Posted (UTC): 2025-03-18
 | Score: 1
 
 Lol 

 
 

 
 
 Comment by: waxbolt
 | Posted (UTC): 2025-03-17
 | Score: 1
 
 I use almost 100% voice input except when I'm in group environments. I talk about what I want for a very long time to provide huge amounts of documentation and perspective to begin from. Of course, they're very disorganized, but by dropping them into a language model, I can get a translation out that's very precise. I then iterate on that translation, updating it. This design document can then be used to implement the entire system. When things are small enough, it's possible to do this in just a few prompts, and I use aider to take large, detailed design documents and then translate them into code. Often when I do this, I use a web-enabled LLM to flesh out the design document with stuff. Another key thing is to put documentation about any essential libraries, modules, APIs that have to be used. This is just required because you can't expect the model to remember or intuit the exact API of the model unless it's something very easy like standard libraries in many languages. If there are any related code bases that I want to work with or translate into another language, these of course get put here. I basically fill the full prompt. I would put more if I could, but the context lengths that are available in the public APIs are still very, very short. By this point, there's a draft of the system I'm trying to build. And I'll start focusing on tests. Writing 1, 2, 3, 10, 20 tests, bit by bit, making sure that they compile, and making sure I understand the result. In some cases, the system is too integrated to have integrated unit tests, and so I'll do a few command lines that I can run, and I'll run these inside of the Ada prompting system itself. I'll show it how to build and how to test. And then it'll propose to do exactly the same process as we continue. At this point, you have to be a little careful not to overfit any tests that get built. And it's extremely easy to have the system come up with solutions that in fact resolve test errors but are completely incorrect. So some attention is really needed at this point. But eventually, things build correctly, the functionality starts to become complete, the tests all work, and it's possible to start applying and developing the system, integrating it into other pieces that you might be working on. A lot of what I'm doing is in the realm of what might be called data science or information science. So I would be then running these across data. I suppose if you were working on web interfaces or graphical user interfaces, then you would then be playing with it yourself or giving it to friends to test. So that's sort of my work flow for green field development, the blue sky projects all have this kind of feeling. But often I have to work on existing code. In those cases, I usually use Ada to extract information out of the code base in a condensed form that I can understand. I'll ask it about the part that I want to modify, ask about algorithms and processes that are related to it, ask about its interfaces, get it to write a design document that can be used by myself and also by the language model to guide any modification of the system. Then having this integrated into the source tree, I may directly modify code or I might pull pieces out in such a way that I can extract functionality if I'm not just adding. I find that working on existing code bases with vibe programming is not easy. It's probably not easy for the same reasons it's not easy to do it yourself. But there is a certain element of messiness to human code that is changed somewhat when vibe coding. What I mean is that there is still messiness, but it becomes harder to see, because the code itself is often beautifully structured and organized, and operating at a very nice level of abstraction. It sits in the median of the abstractions that you see people using in the wild. 


 
 
 Comment by: Corvoxcx
 | Posted (UTC): 2025-03-18
 | Score: 1
 
 Thanks for all of this context. 

 
 

 
 
 Comment by: GentReviews
 | Posted (UTC): 2025-03-17
 | Score: 1
 
 Plan make a flow chart tell deepseek revise and expand the plan hand the plan to qwen where it is instructed to create a skeleton then reprompted to add doc strings to explain intent for each function at wich point it’s passed back to deepseek to add basic functions and specific details about implementation strategies then it goes to gpt4 for some implementation expansion and error handling and finally shoved into Claude 3.5 to do its business 👨‍💼 Sound like a lot but it’s pumping out 5k lines of quality on a almost single prompt Then the full stack is exported into vs code for copilot and roo code 100% free nearly 100% automated and all high quality models the only downside is you need to watch the screen a bit 😂 


 
 
 Comment by: Corvoxcx
 | Posted (UTC): 2025-03-18
 | Score: 2
 
 Thanks for this. I'm trying to keep costs low. 


 
 
 Comment by: GentReviews
 | Posted (UTC): 2025-03-18
 | Score: 1
 
 If you have a decent gpu go a step further and spin up ollama or litellm with owu(if you use ollama) and use it first as your planning step gl 

 
 
 

 
 
 Comment by: bdubbber
 | Posted (UTC): 2025-03-17
 | Score: 1
 
 I start by “writing” a product brief. Iterate on this until I’m happy. This has been with Claude recently and I doubt I change that anytime soon. I’ll often incl tech choices/architecture in here, along with anything else thats important for context (marketing, user types, whatever whatever) If there is need for more than basic UX, I’m using galileo for some app design, depending on what i’m up to. I find it is best with (generic) mobile design. It has a really hard time keeping systems consistent from step to step in an app, so often have to give it a little cleanup in figma. Then back to Claude to code it up. I need to try cursor and these other more robust tools 


 
 
 Comment by: Corvoxcx
 | Posted (UTC): 2025-03-18
 | Score: 2
 
 Thanks! 

 
 

 
 
 Comment by: nothalfas2
 | Posted (UTC): 2025-03-18
 | Score: 1
 
 Start Process: I fire up replit, blurt out some amazing genius idea like "a website to entertain pugs while their owner is at work". Replit's Agent spits out a plan. I revise it a bit, only from feature POV not architecture. I then look at whatever slop it throws together on its first try, and say stuff like "Nice! but make all the buttons shaped like pug ears". Usually we get there, evolving the idea through chat. Debugging and problems: Sometimes delete the app and start over, if the codebase gets too tangled. Rarely I write some script myself but I don't compile - I keep the Agent in the drivers seat: "I decided to write the dog-nose sensing feature --see dog-nose.py. Have a look and integrate it." Tools: I tried VS Code with agents but the vibe was more "Agent, help a programmer build something". I want a more holistic setup, like "Agent, build what a techie product guy wants". I've been using Replit. Its Agent (Claude Sonnet 3.7) is fearless: it just has a whack at it. It churns and gets stuck then we have to untangle its mess together. WHen that gets annoying I work with the Assistant (also Claude Sonnet 3.7) which is more careful, lets me discuss, keeps me in the drivers seat on which script is being edited. I find Replit's UX intuitive - the chat window, the progress window, console, and some basic version control and web preview and one-click deploy, all make sense. Not that I don't think I can improve it as per my "Firestarter" idea :) Curious and excited by you-all who are feeding agents into agents. Seems like you-all have rolled your own to do that. Replit's not really set up for that. WOndering if some other platforms like it are.


id: cfb61dfd0b17
title: Show HN: DD Photos – open-source photo album site generator (Go and SvelteKit)
source_url: https://github.com/dougdonohoe/ddphotos
source_platform: hackernews
author: dougdonohoe
published_at: 2026-03-10T13:13:48+00:00
collected_at: 2026-03-11T01:03:37.071118+00:00
scenario_type: 工作流自动化
tools_used: ["Go", "SvelteKit", "Claude Code", "Playwright", "Docker", "Apache", "S3"]
novelty: new
similar_to_ids: []
summary:
DD Photos是一个开源照片相册网站生成器，通过Go CLI工具自动化处理照片转换和索引生成，部署为静态SvelteKit站点。该项目解决了传统照片分享平台的痛点，通过本地工作流自动化实现了快速、无服务器的照片共享解决方案。

raw_content:
Show HN: DD Photos – open-source photo album site generator (Go and SvelteKit)

I was frustrated with photo sharing sites. Apple&#x27;s iCloud shared albums take 20+ seconds to load, and everything else comes with ads, cumbersome UIs, or social media distractions. I just want to share photos with friends and family: fast, mobile-friendly, distraction-free.<p>So I built DD Photos. You export photos from whatever you already use (Lightroom, Apple Photos, etc.) into folders, run `photogen` (a Go CLI) to resize them to WebP and generate JSON indexes, then deploy the SvelteKit static site anywhere that serves files. Apache, S3, whatever. No server-side code, no database.<p>Built over several weeks with heavy use of Claude Code, which I found genuinely useful for this kind of full-stack project spanning Go, SvelteKit&#x2F;TypeScript, Apache config, Docker, and Playwright tests. Happy to discuss that experience too.<p>Live example: <a href="https:&#x2F;&#x2F;photos.donohoe.info" rel="nofollow">https:&#x2F;&#x2F;photos.donohoe.info</a>
Repo: <a href="https:&#x2F;&#x2F;github.com&#x2F;dougdonohoe&#x2F;ddphotos" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;dougdonohoe&#x2F;ddphotos</a>


id: ef284a502c1b
title: The Complete Guide to Vibe Coding — AI‑Powered Development Workflows
source_url: https://www.reddit.com/r/vibecoding/comments/1lth1l0/the_complete_guide_to_vibe_coding_aipowered/
source_platform: reddit
author: unknown
published_at: 2026-03-11T01:00:10.288395+00:00
collected_at: 2026-03-11T01:03:47.112054+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude", "Cursor", "plugged.in", "GitHub", "Sourcery", "MCP"]
novelty: similar
summary:
本指南介绍了'Vibe Coding'工作流，展示如何通过Claude、Cursor等AI工具与GitHub、Sourcery等开发平台集成来优化软件开发过程。涵盖AI驱动的代码审查、任务分解、CI/CD流程和文档自动化等实践，具有较强的实际应用价值。

similar_to_ids:
["19e007cf2bb9", "bf709374985d", "a90e1fa2514d", "8b8b74bdb5b3", "cba07222d406", "4e8f450b17be", "c4c047193758"]

raw_content:
The Complete Guide to Vibe Coding — AI‑Powered Development Workflows

Reddit - The heart of the internetSkip to main content

r/vibecoding icon
Go to vibecoding
r/vibecoding•
babaenki
# The Complete Guide to Vibe Coding —AI‑Powered Development Workflows
I’ve just published an in-depth guide on*vibe coding*— the art of developing software by collaborating with AI tools like Claude, Cursor, and plugged.in. This includes:
* Using GitHub as the backbone of AI workflows
* Structuring AI‑readable PRDs
* Command‑centered MCP setup viaplugged.in
* AI‑driven code reviews with Sourcery
* Security scanning, CI pipelines, and documentation as code
* Breaking work into 15‑minute, AI‑digestible tasks
It’s based on my real‑world experience integrating AI into development practices. I’d love to hear your feedback!
🔗https://medium.com/@cem.karaca/the-complete-guide-to-vibe-coding-best-practices-for-ai-powered-development-5529dedfd2a7
Read more
Share
New to Reddit?
Create your account and connect with a world of communities.
Continue with Email
By continuing, you agree to ourUser Agreementand acknowledge that you understand thePrivacy Policy.
sunsetsunset
VibeJam is happening!
Public
Anyone can view, post, and comment to this community
00
Reddit RulesPrivacy PolicyUser AgreementAccessibilityReddit, Inc. ©2026. All rights reserved.
Expand NavigationCollapse Navigation


id: c22de644b867
title: My Vibe Coding Steps : r/vibecoding
source_url: https://www.reddit.com/r/vibecoding/comments/1r2jbfv/my_vibe_coding_steps/
source_platform: reddit
author: unknown
published_at: 2026-03-11T01:00:10.288407+00:00
collected_at: 2026-03-11T01:04:09.806554+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude", "Claude Code", "Google AI Pro (Gemini)", "skills.sh", "Major"]
novelty: similar
similar_to_ids: ["ef284a502c1b", "19e007cf2bb9", "bf709374985d", "5de829326949", "4e8f450b17be"]
summary:
用户分享了一套完整的AI辅助开发工作流程，通过Claude进行迭代讨论、规划审查和代码优化，结合多个AI工具和技能工具来构建针对教堂和小企业的公开应用。该工作流强调了快速迭代、人工审查和多角色AI协作的实践价值，已成功交付5个产品。

raw_content:
My Vibe Coding Steps : r/vibecoding

My Vibe Coding Steps : r/vibecodingSkip to main contentMy Vibe Coding Steps : r/vibecoding

r/vibecoding icon
Go to vibecoding
r/vibecoding•11h ago
Previous-Tie-2537
# My Vibe Coding Steps
You didnt ask but here is my work flow I have developed over the last few months Vibe coding.
1. Come up with an idea to solve a problem and discuss it with Claude... like generally discuss it.
2. Ask Claude to give its input into the idea and give me some pointers on what would make it better
3. Interact with discussion by communication which additions I DO NOT want to do.
4. This is key. Ask Claude to act as a App Developer with and expertise in [code subject] and write out an MD file with all features and tech stack
5. IMPORTANT: TAKE A FULL DAY BREAK. I pause from the idea to step back and see if it's really needed or will it really solve a problem
6. Ask Claude to become a hard nosed executive in Web App Development and review the plan with a fine tooth comb and elminate and DUMB idea that's in the scope. It usually fixes all the features and prioritizes each idea.
7. Re-do the MD file including phases and timelines including debugging and deployment.
8. Build Phase by phase and test each phase.
9. After deploying to my server stress test my own app and send it out to a small group of experts in that app subject and then get complaints from them.
10. Take those back Claude and ask it to FIX any issues OR remove unused features.
11. I use a skill to build the front end and get it looking somewhat decent
12. I use a skill to review the backend and all the code and tell it piece by piece to fix any code that is bloated.
Other notes: The skills feature is killer skills.sh. If I use anti-gravity to fix small issues with Gemini, I ask Claude when my tokens restore to review any changes, and correct any code and don't change any other parts of said app. This flow has helped each app get easier and easier to build. Feel free to critique add to or insult my flow. My price per month is $20 for Claude and $21 for Google AI Pro and for the most part I don't run out of any tokens swithching between them.
Read more
Share
u/acefuzion avatar
acefuzion
•11h ago
is anything you're trying to build internal to your company or are these all standalone public apps/tools?
1
u/Previous-Tie-2537 avatar
Previous-Tie-2537
•11h ago
Most of them will be public tools I have 5 builts. Just working out the kinks. They are for a very specific niche (churches and small businesses) I took they tools they ask me to use and simplified them but then started expanding feature sets for each app. One I can share is:https://usepromptr.io/Cloud based teleprompter app for content creators Fully functional and works on every browser.
1
u/acefuzion avatar
acefuzion
•11h ago
that's awesome! If you need to vibe code tools that need auth, user management, and can integrate with some of your existing tools,try out this tool calledMajor. It's helped me a lot at work.
0
2more replies
2more replies
Continue this threadContinue this threadContinue this thread
u/_donvito avatar
\_donvito
•10h ago
Using Skills is definitely a game-changer. Do you use subagents?
1
u/Previous-Tie-2537 avatar
Previous-Tie-2537
•9h ago
Not yet. I am really a novice vibe coder...only really use the desktop app and antigravity. I need to look into what they do since I hear it would help my flow
2
u/_donvito avatar
\_donvito
•9h ago
ah it breaks down a task into parallel runs using subagents. claude has it
https://code.claude.com/docs/en/sub-agents
1
1more reply
1more reply
Continue this threadContinue this thread
u/Splashy01 avatar
Splashy01
•6h ago
What’s this “Skills” you speak of?
1
u/Select_Lemon_5202 avatar
Select\_Lemon\_5202
•5h ago
skill is set of instructions like the system prompt but in different areas, the most popular I see is front-end developer from Anthropic.
1
Continue this threadContinue this thread

slothcriminal
•7h ago
Are you using GitHub between the 2 LLMs, or just working within a single directory?
1


Firm\_Ad9420
•7h ago
The full-day break step is underrated. Most people skip that and end up polishing ideas that shouldn’t exist. I also like the “hard nosed exec” phase —forcing prioritization early probably saves a lot of downstream refactoring. The only thing I’d add is explicitly defining system boundaries before build (what owns state, what doesn’t), since that’s where AI flows tend to drift.
1
u/FinAdda avatar
FinAdda
•6h ago
Where is your code written? By Claude Code or Gemini?
I ran out of credits fast with Claude Code plug in.
1
u/Select_Lemon_5202 avatar
Select\_Lemon\_5202
•5h ago
You should revise your behavior always when you interact, reduce MCPs, mention the affected files when you need to add some features ...etc.
1
Continue this thread

MalouinBuilds
•3h ago
the full day break is the move honestly. i've killed so many half baked ideas just by sleeping on them
1

pakotini
•3h ago
This is a solid flow. The full day break and the hard nosed exec review probably save you from shipping a lot of unnecessary scope. Most people skip that and just start polishing. One thing I would add is locking in system boundaries before you build. Decide clearly what owns state, what persists data, and what is just UI glue. That is where AI projects usually drift and create hidden tech debt. Also, if you like this kind of structured back and forth, you might enjoy running it inside something like Warp with Oz. Oz is launching this week and it is built around persistent context and execution inside your real repo, so you are not constantly re uploading state. It feels closer to a real environment than just chatting in a desktop app.
1
# Related Answers Section
Related Answers
Innovative AI tools for creative coding
AI coding tools have revolutionized the way developers approach coding, offering both significant advantages and unique challenges. Here's a succinct guide to the best AI coding tools and practices, based on the experiences and opinions of Redditors.
### Best AI Coding Tools
* **Claude Code**: Highly recommended for its detailed and accurate code generation."Claude is demonstrating superior performance to GPT, particularly in terms of detail and sectioning."
* **Codex**: Praised for its user-friendliness and efficiency."Codex and Claude Code are the main two coding agents that are the most user friendly and for your purposes they will both work exceptionally well."
* **Cursor**: Known for its ability to maintain context and assist in complex coding tasks."If you aren't using an IDE or coding tool/terminal with some kind of codebase awareness, then you are missing out."
* **Kilo Code**: Integrates with v0 and offers improved UI results."You can try Kilo Code in VS Code... The UI results have been way better than what I usually get from other models."
### Practices for Effective AI Coding
* **Detailed Prompting**: Provide specific instructions and constraints to ensure the AI generates code that meets your design requirements."What you should be doing is giving them constraints."
* **Design Systems**: Use design systems like Figma to guide the AI in creating consistent and professional-looking UIs."Build a design system on figma and point the AI to the files."
* **Module Management**: Keep code modules small to help the AI maintain context and avoid generating inconsistent logic. "Keep Modules Small. Modules over 500–800 lines? Break them up."
* **Review and Refine**: Regularly review the AI-generated code and make necessary adjustments to ensure it meets your standards."Reviewing AI slop you are not working on your skills."
### Challenges and Considerations
* **Code Quality**: AI-generated code can often be bloated and suboptimal, requiring significant cleanup."Claude can spit out code really fast. But it often fails to get the details right, tends to code very bloated and most importantly: it makes mistakes."
* **Learning Curve**: Using AI tools effectively requires a good understanding of prompting and design principles. "Unless you have a background in engineering and UX you are going to struggle to get really good results."
* **Maintainability**: While AI can accelerate coding, it does not necessarily improve the maintainability of the code."Using AI to develop code has little to no impact on the maintainability of the code later."
### Subreddits for Further Questions
* r/Backend
* r/vibecoding
* r/ChatGPTCoding
* r/learnprogramming
These communities are great places to ask for more advice and share your experiences with AI coding tools.
See Answer

Unique programming languages to explore


How to enhance coding with music


Best practices for vibe coding techniques


AI-generated art: tools and tips

New to Reddit?
Create your account and connect with a world of communities.
Continue with Email
Continue With Phone Number
By continuing, you agree to ourUser Agreementand acknowledge that you understand thePrivacy Policy.
# More posts you may like
* My vibe coding setup. What is your vibe coding process?

r/vibecoding icon
r/vibecoding
•6d ago

### My vibe coding setup. What is your vibe coding process?

r/vibecoding - My vibe coding setup. What is your vibe coding process?
2
34upvotes·17comments
* Should I learn to code while vibe coding?

r/vibecoding icon
r/vibecoding
•2mo ago

### Should I learn to code while vibe coding?

3upvotes·35comments
* I'd say this will 10x your vibe coding - exaggerating?

r/vibecoding icon
r/vibecoding
•27d ago

### I'd say this will 10x your vibe coding - exaggerating?

28upvotes·11comments
* * legit how vibe coding feels like (when done right)

r/vibecoding icon
r/vibecoding
•22d ago

### legit how vibe coding feels like (when done right)

r/vibecoding - legit how vibe coding feels like (when done right)
70upvotes·54comments
* My Vibe Coding Journey

r/vibecoding icon
r/vibecoding
•6mo ago

### My Vibe Coding Journey

r/vibecoding - My Vibe Coding Journey
1.8Kupvotes·135comments
* Does vibe coding work for people who don't know how to program

r/vibecoding icon
r/vibecoding
•2mo ago

### Does vibe coding work for people who don't know how to program

8upvotes·87comments
* The result of vibe coding

r/vibecoding icon
r/vibecoding
•22d ago

### The result of vibe coding

r/vibecoding - The result of vibe coding
59upvotes·34comments
* Helpful tips from a dev background and hundreds upon hundreds of hours of vibe coding

r/vibecoding icon
r/vibecoding
•5mo ago

### Helpful tips from a dev background and hundreds upon hundreds of hours of vibe coding

69upvotes·20comments
* * After two weeks of back-and-forth, I'm convinced vibe coding is just expensive debugging with extra steps

r/vibecoding icon
r/vibecoding
•3mo ago

### After two weeks of back-and-forth, I'm convinced vibe coding is just expensive debugging with extra steps

131upvotes·212comments
* Vibe coding has taught me an important lesson.

r/vibecoding icon
r/vibecoding
•1mo ago

### Vibe coding has taught me an important lesson.

47upvotes·31comments
* What are you vibe coding right now? 🚀

r/vibecoding icon
r/vibecoding
•5mo ago

### What are you vibe coding right now? 🚀
48upvotes·224comments
* Vibe Coding is now just...Coding

r/vibecoding icon
r/vibecoding
•3mo ago

### Vibe Coding is now just...Coding

r/vibecoding - Vibe Coding is now just...Coding
1.1Kupvotes·407comments
* Ive been vibe coding too much.

r/vibecoding icon
r/vibecoding
•1mo ago

### Ive been vibe coding too much.

92upvotes·71comments
* Vibe Coding is Addictive

r/vibecoding icon
r/vibecoding
•1mo ago

### Vibe Coding is Addictive

r/vibecoding - Vibe Coding is Addictive
534upvotes·38comments
* vibe-coding –need beginner tips

r/vibecoding icon
r/vibecoding
•15d ago

### vibe-coding –need beginner tips

4upvotes·15comments
* What are you actually building with vibe coding?

r/vibecoding icon
r/vibecoding
•25d ago

### What are you actually building with vibe coding?

10upvotes·58comments
* I wanna start learning vibe coding. Where do I start?

r/vibecoding icon
r/vibecoding
•1mo ago

### I wanna start learning vibe coding. Where do I start?

1upvote·20comments
* vibe coding is fun until you realize you dont understand what you built

r/vibecoding icon
r/vibecoding
•2mo ago

### vibe coding is fun until you realize you dont understand what you built

141upvotes·42comments
* What's stopping you from vibe coding like this?

r/vibecoding icon
r/vibecoding
•4mo ago

### What's stopping you from vibe coding like this?

23upvotes·14comments
* Choose one vibe coding tool for every.

r/vibecoding icon
r/vibecoding
•7d ago

### Choose one vibe coding tool for every.

1upvote·33comments
* I’m not sure I understand vibecoding?

r/vibecoding icon
r/vibecoding
•5d ago

### I’m not sure I understand vibecoding?

34upvotes·30comments
* Vibe coding W

r/vibecoding icon
r/vibecoding
•1mo ago

### Vibe coding W

r/vibecoding - Vibe coding W
655upvotes·43comments
* Vibe coding is a learning tool

r/vibecoding icon
r/vibecoding
•4mo ago

### Vibe coding is a learning tool

34upvotes·36comments
* Whats your current and preferred vibe coding stack?

r/vibecoding icon
r/vibecoding
•7d ago

### Whats your current and preferred vibe coding stack?

3upvotes·24comments
## View Post in
Français
sunsetsunset
VibeJam is happening!
Public
Anyone can view, post, and comment to this community
00
Reddit RulesPrivacy PolicyUser AgreementYour Privacy ChoicesAccessibilityReddit, Inc. ©2026. All rights reserved.
Expand NavigationCollapse Navigation


id: 8d0142693489
source_platform: reddit
author: unknown
published_at: 2026-03-11T01:00:10.288411+00:00
collected_at: 2026-03-11T01:04:23.603753+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude Code", "Codex", "Cursor", "GPT 5.3", "Opus 4.6"]
novelty: similar
similar_to_ids: ["c22de644b867", "ef284a502c1b", "19e007cf2bb9", "8b8b74bdb5b3", "4e8f450b17be"]
title:
I think we've quietly moved past "vibe coding" into something that needs a better name : r/accelerate

summary:
作者分享了与AI代理协作编写软件的演变过程，从"氛围编程"升级到"代理工程"，强调通过编写规范、定义验收标准、管理代理上下文和运行验证循环来实现系统级工程实践。最新的大型语言模型在长步骤任务执行、可靠的工具使用、指令遵循和大上下文处理方面的改进，使得这种工程化的AI辅助开发工作流成为可能。

source_url:
https://www.reddit.com/r/accelerate/comments/1r980su/i_think_weve_quietly_moved_past_vibe_coding_into/

raw_content:
I think we've quietly moved past "vibe coding" into something that needs a better name : r/accelerate

I think we've quietly moved past "vibe coding" into something that needs a better name : r/accelerate Skip to main content I think we've quietly moved past "vibe coding" into something that needs a better name : r/accelerate

Go to accelerate

r/accelerate 1d ago

bobo-the-merciful

# I think we've quietly moved past "vibe coding" into something that needs a better name

I've been building software almost entirely with AI agents for about a year now. Claude Code, Codex, Cursor, the works. And sometime in the last few months the way I work changed in a way I didn't immediately have words for.

"Vibe coding" always carried a bit of a derogatory undertone. It implied you were vibes-only, prompting and praying, accepting whatever the model spat out. And for most of 2025 that wasn't entirely unfair. You'd prompt, get output, manually fix the obvious problems, prompt again. The human was sort of along for the ride.

That's not what I'm doing anymore. I don't think it's what most people in this sub are doing either.

What my workflow actually looks like now is closer to systems engineering. I write specs. I define acceptance criteria. I manage agent context across sessions. I run verification loops. I monitor agent behaviour and correct course when it drifts. The code gets written by the agent, but the engineering is entirely mine.

I've been calling it "agentic engineering" in my head. Specify, delegate, verify. Not vibes.

So what actually crossed the threshold? A few specific things, mostly in the last six months with models like Opus 4.6 and GPT 5.3.

Sustained agentic loops. Models can now execute 20, 30, 50-step task sequences without losing the plot. Read a file, edit code, run tests, see the failure, fix it, run again. Before this you'd get maybe 5-8 steps before context drift killed the session. Now it just works. Not always. But enough that you can build a process around it.

Reliable tool use. File editing, terminal commands, test execution. Sounds basic but this is what makes delegation possible at all. You can't engineer a process around an unreliable executor.

Instruction adherence got quietly good enough. Earlier models would acknowledge your spec and then do whatever they felt like. Now you can actually constrain behaviour and it sticks. Not perfectly (I still get the occasional "I decided to refactor your entire module while I was at it" moment) but the baseline shifted in a way that matters.

Hallucination rate dropped to where verification is catching edge cases rather than filtering constant fabrication. That's a qualitative change in how the workflow feels. You go from "assume wrong, check everything" to "assume right, spot-check." Completely different engineering posture.

And effective use of large context. Not just bigger windows, but actually holding the codebase architecture in working memory. Changes that are consistent with the rest of the system rather than just locally correct in isolation.

The other thing that doesn't get discussed enough is the tooling ecosystem maturing alongside the models. Context management is the big one. Models still degrade as you burn through context, that's real, and anyone who tells you otherwise hasn't tried a long enough session. But tools like BEANS, Beads, Claude Code's built-in memory, and whatever Codex is doing behind the scenes (because it's suspiciously good at long-running tasks) are closing this gap fast. Six months ago context degradation was a hard ceiling on what you could do in a single session. Now it's becoming a managed engineering constraint. There's also agent orchestration, CI integration, structured plans as first-class workflow artefacts. An entire infrastructure layer that didn't exist in the prompt-and-pray era.

The reason I think the name actually matters is that "vibe coding" keeps the conversation stuck at "is AI code any good?" Agentic engineering moves it to "how rigorous is your engineering process?" That's the real differentiator between people producing good output and people producing slop. It's not the model. It's the process wrapped around the model.

"Classical" vibe coders are still out there. Prompting without specs, accepting without verifying, shipping without testing. But that's not what this is, and lumping everything together makes it harder to talk about what actually works.

TL;DR: what practitioners are doing now is systems engineering with an AI execution layer and "vibe coding" no longer sensibly describes what is happening

Read more

Share

---

Alive-Tomatillo5303

1d ago

It's like saying you're using a digital camera. First it was noteworthy, then it was assumed, and now you'd have to specify if you were using a film camera.

Soon, "vibe" coding will just be... coding. And somewhere someone who can't let go will be doing "manual" coding and making a big deal out of it.

37

alias454

1d ago

Would you like some of my artisanal handcrafted apps?

7

Mono_Morphs

1d ago

Saw that with Python among other ones - each iteration the previous layer of complex granularity seems to have that transition. Interestingly to me, is that the previous generation of "grew up/learned at the current tech level" have a tremendous advantage in the newer abstraction layer, but I think it's also a bit of a shell shock as to what changes and how upended their trained workflow becomes.

That said, AI coding has a lot to work on, but given that advancements seem to be coming out so rapidly this will be likely an out of date comment quite quickly.

4

jazir555

1d ago

Imo it'll be a solved problem by the end of the year. To the point that it can oneshot a majority of vaguely defined tasks without granular specificity. Saying "Make me a solidworks clone" and it just works will probably actually be possible within a year or two, as unbelievable as that sounds right now.

2

1 more reply

Continue this thread Continue this thread

DualityEnigma

1d ago

I really relate to this. For the first time in a long time I have an app that is production ready, the way I want it. Because I built it with AI. All the way through, I was like. This is just coding… but amazingly faster and more helpful.

Test coverage Vanity features

All attainable

3

sentinel_of_ether

1d ago

I think a calculator is a better comparison. This is like when teachers said “you won’t always have a calculator in real life.”

But that comparison makes the same mistake yours does. Its still extremely valuable to know the math behind the calculator. Its still very important to know the code behind your vibe code sessions. Especially in any real world scenario when you are dealing with large pipelines and cross system architecture. Otherwise, they could just fire every software engineer today and hire you guys for half the cost. We all know why that isn’t going to happen. Syntax was only one barrier to the engineering field…removing that does not suddenly make everyone engineers.

-1

Alive-Tomatillo5303

1d ago

Otherwise, they could just fire every software engineer today and hire you guys for half the cost.

You're so close to getting it.

2

5 more replies

Continue this thread Continue this thread Continue this thread

Belostoma

1d ago

As a scientist I've been using AI extensively for math/coding for two years now, and I just finally jumped on the agentic train. I have gradually grown more comfortable with skipping manual review on larger and larger chunks of code, depending on their function, but I've still been locked into a workflow based largely on copying and pasting between AI and my IDE. Partly that's because I don't have API credits, and I did not until recently know of a way to integrate coding agents on my flat $20/ month plan. I also got a mildly sour impression of agentic coding when I tried it back around o1 or so and had to fix things AI broke when it was free to modify my code willy nilly.

I just got gpt-5.3-codex integrated into my IDE and workflow this week, combined with having taken several days of deep research just to refine my specs, and... holy fuck. I've been missing out!

I do think that if I had turned codex loose on my existing codebase with the perpetual goal of "fix the next bug that pops up," it might have devolved deeper and deeper into spaghetti. But I am blown away by what I'm getting out of it with a clear plan for the architecture, standards, etc.

Everything you're saying about your "systems engineering" workflow resonates very strongly with what I'm just coming to realize. I'm curious if you've just been figuring this out as you go along too, or if you have any resources you're following to stay on top of the best practices.

10

Anxious-Alps-8667

1d ago

I just have to chime in that I think these are phase transitions in capability. I have been having my own personal holy fuck moments since GPT 5, to Opus 4.5, Gemini 3, etc. I have been having them at a faster rate (basic acceleration theory, I guess). I had one yesterday with minimax 2.5, and I'm having another one today with Gemini 3.1 Pro.

One a day is a lot; I have to reset my own transition gradient.

2

Continue this thread

Stock_Helicopter_260

1d ago

SW architecture design.

You’re not writing code blocks anymore, it does that. You design the whole.

If you try and get it to the do the architecture on a project that is too large for it to handle, a target which is moving every day, then you’re vibe coding.

2

my_shiny_new_account

1d ago

"software development"

4

random87643

1d ago

Post TLDR: The author argues that the practice of software development using AI agents has evolved beyond "vibe coding," where developers relied on prompts and accepted whatever the AI generated. Now, the workflow resembles systems engineering, involving writing specs, defining acceptance criteria, managing agent context, running verification loops, and monitoring agent behavior. This shift is due to improvements in AI models like Opus 4.6 and GPT 5.3, enabling sustained agentic loops, reliable tool use, better instruction adherence, reduced hallucination rates, and effective use of large context windows. The maturing tooling ecosystem, including context management and agent orchestration tools, also plays a crucial role. The author proposes the term "agentic engineering" to emphasize the importance of a rigorous engineering process around the AI model, rather than just the model itself, to produce high-quality output, concluding that practitioners are now doing systems engineering with an AI execution layer.

3

peakedtooearly

1d ago

AI pair programming.

3

Legal_Set_8756

1d ago

We call it “agentic coding” at work.

2

Continue this thread

FateOfMuffins

1d ago

https://x.com/i/status/2019137879310836075

Karpathy has also been calling it agentic engineering

9

Wizzard_2025

1d ago

Blind driving

-1

Anxious-Alps-8667

1d ago

Allow me to humbly offer my own proposal!

https://www.reddit.com/r/accelerate/comments/1qb09s6/a_humble_proposal_for_the_2026_word_of_the_year/

That said, I'm totally good with a universe where 'chonking' and 'agentic engineering' co-exist as helpful terms, and we're going to need many others to describe the array of use cases and scenarios.

2

Continue this thread

soliloquyinthevoid

1d ago

I've been calling it "agentic engineering" in my head. Specify, delegate, verify. Not vibes.

You're a tech lead that delegates tasks to a junior. The junior just happens to be a computer instead of a human

You spend increasing time on defining the 'what' and less on the 'how'. Congratulations, you've been promoted

0

sentinel_of_ether

1d ago

The “I’m a software engineer now” posts are so fucking funny I love this sub

-1

jdyeti

1d ago

I've heard centaur coding which feels accurate

1

TwistStrict9811

1d ago

"Agent orchestrator" or something like that

1

Revolutionalredstone

1d ago

I'm seeing the pattern that most people just pass it off as their own work (sometimes there's a tiny, this is 90% vibe coded near the bottom)

IMHO it doesn't matter who / how, it only matters what / is.

I think we're already past the point where vibe projects are better than average coders projects so it's hard to argues it's a bad thing ;D

1

IReportLuddites

1d ago

"Hitachicoding"

1

costafilh0

1d ago

How about: CODING

1

drumnation

13h ago

Agentic engineering

1

---

## View Post in

Português (Brasil)

Reddit Rules Privacy Policy User Agreement Your Privacy Choices Accessibility Reddit, Inc. © 2026. All rights reserved.


id: 56bce697cfa3
title: Kong/kong
source_url: https://github.com/Kong/kong
source_platform: github
author: Kong
published_at: 2026-03-10T03:46:08+00:00
collected_at: 2026-03-11T01:04:33.923277+00:00
scenario_type: 工作流自动化
tools_used: ["Kong", "API Gateway", "AI Gateway", "LLM Gateway", "Kubernetes", "Reverse Proxy"]
novelty: similar
similar_to_ids: ["bc0fb2ea1445", "97dcab4759c8", "5471379ee4ff", "c37165a31cd3"]
summary:
Kong是一个开源API和AI网关，支持API管理、微服务治理、LLM操作和云原生部署。该项目为企业提供了统一的API和AI流量管理平台，具有较高的生产应用价值，特别是在Kubernetes环保和微服务架构中。

raw_content:
Kong/kong

🦍 The API and AI Gateway

Topics: ai, ai-gateway, api-gateway, api-management, apis, artificial-intelligence, cloud-native, devops, kubernetes, kubernetes-ingress, kubernetes-ingress-controller, llm-gateway, llm-ops, mcp, mcp-gateway, microservice, microservices, openai-proxy, reverse-proxy, serverless
Language: Lua | Stars: 42918


id: 845dff761b29
title: nextlevelbuilder/ui-ux-pro-max-skill
source_url: https://github.com/nextlevelbuilder/ui-ux-pro-max-skill
source_platform: github
author: nextlevelbuilder
published_at: 2026-03-10T06:05:57+00:00
collected_at: 2026-03-11T01:05:22.797039+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude", "Claude Code", "React", "Tailwind CSS", "HTML5", "Python"]
novelty: similar
similar_to_ids: ["da5e5724c2e9", "aea12527477e", "cba07222d406", "c22de644b867"]
summary:
这是一个AI技能项目，利用Claude提供设计智能来帮助在多个平台上构建专业的UI/UX。项目集成了React、Tailwind CSS等现代前端技术，通过命令行工具和代码生成能力加速UI设计和开发流程。该项目在开源社区获得了显著关注（39601星），展示了AI辅助设计工具的实际价值。

raw_content:
nextlevelbuilder/ui-ux-pro-max-skill

An AI SKILL that provide design intelligence for building professional UI/UX multiple platforms

Topics: ai-skills, antigravity, claude, claude-code, codex, command-line, copilot, cursor-ai, html5, kiro, landing-page, mobile-ui, qoder, react, tailwindcss, trae, ui-design, uikit, windsurf-ai
Language: Python | Stars: 39601


id: e1e06f6feb29
source_platform: reddit
author: t2_1uy5xd3aj6
published_at: 2026-03-11T01:00:10.288427+00:00
collected_at: 2026-03-11T01:05:48.895052+00:00
scenario_type: 终端与CLI增强
tools_used: ["Claude Code", "Claude Agent SDK", "npm", "Node.js", "Browser"]
novelty: similar
similar_to_ids: ["c1c03fd9146d", "52d44a688882", "1d33fcd888f9"]
title:
https://www.reddit.com/r/VibeCodingSaaS/comments/1ris3yo/i_built_an_opensource_tool_to_run_claude_code_on.json

summary:
VibeCheck是一个开源工具，将Claude Code代理部署到服务器作为后台服务运行，允许用户从任何浏览器设备连接和使用，解决了Claude Code受限于本地终端会话的问题。该工具支持会话持久化、跨设备访问、实时流式处理和成本追踪，同时提供自托管和云托管两种使用方式。

source_url:
https://www.reddit.com/r/VibeCodingSaaS/comments/1ris3yo/i_built_an_opensource_tool_to_run_claude_code_on.json

raw_content:
https://www.reddit.com/r/VibeCodingSaaS/comments/1ris3yo/i_built_an_opensource_tool_to_run_claude_code_on.json

I got tired of needing my laptop open to use Claude Code. So I built VibeCheck — it runs a Claude Code agent on your server as a background service, and you connect from any browser.

https://i.redd.it/v0r8hbdfqmmg1.gif

**The problem:** 
Claude Code is great, but it's tied to the terminal session on your machine. Close your laptop → session dies. Want to check progress from your phone → can't.



**How VibeCheck works:**

1. Install the agent on your server: `npm i -g vibecheck-agent`
2. It runs Claude Code headless via the Claude Agent SDK
3. Open any browser — phone, tablet, another PC — and start coding
4. Close your laptop. The agent keeps running. Come back tomorrow and pick up where you left off

Sessions are stored as `.jsonl` in `~/.claude/projects/` — the same format Claude Code CLI uses. So web sessions show up in CLI, and CLI sessions show up in the web.

**Features:**

* Real-time streaming with tool visualization ("Reading file...", "Editing code...")
* Browse all Claude Code projects on the server, resume any session from any device
* Skills system — Research / Coding / Code Review / Test Runner presets
* Task scheduler with cron expressions
* Cost tracking per response (USD + token breakdown)
* Path-based security with approval UI

**vs Anthropic's Remote Control:** 
Anthropic shipped `claude remote-control` last week — it lets you monitor a local Claude session from another screen. Different use case. VibeCheck runs the agent on a server, so there's no local process to keep alive. Your PC can be completely off.

**Self-hosting is free forever** — MIT licensed, your server, your data, no limits.

A hosted version is available at vibecheck.sotaaz.com so you don't have to manage your own server. It's free to start, with a paid tier planned for heavier usage.

**Contributing:** 
The project is fully open source and contributions are welcome. There are `good first issue` labels on GitHub if you're looking for a place to start.

→ GitHub: github.com/NestozAI/VibeCheck

Happy to answer any questions.


id: 129d264430ea
source_url: https://www.reddit.com/r/ClaudeAI/comments/1r84a3f/those_of_you_who_use_claude_code_in_automode_vs/
source_platform: reddit
author: unknown
published_at: 2026-03-11T01:00:11.422103+00:00
collected_at: 2026-03-11T01:06:00.522978+00:00
scenario_type: 终端与CLI增强
tools_used: ["Claude Code", "Axon", "Kubernetes", "Docker", "Git", "GitHub Issues", "GitHub PRs"]
novelty: similar
similar_to_ids: ["e1e06f6feb29", "257ed0953657", "3fff252b35ec", "db0fc62f4243"]
title:
Those of you who use Claude Code in auto-mode vs. those who don't — what's your experience? : r/ClaudeAI

summary:
讨论Claude Code自动模式的使用体验和最佳实践，展示了从本地机器、Docker到Kubernetes等不同隔离方案的对比。Axon工具通过Kubernetes容器实现了完全自主的代码代理，可自动从GitHub Issue生成PR，降低了在本地机器上运行自主代理的安全风险。

raw_content:
Those of you who use Claude Code in auto-mode vs. those who don't — what's your experience? : r/ClaudeAI

Those of you who use Claude Code in auto-mode vs. those who don't — what's your experience? : r/ClaudeAI Skip to main content

Go to ClaudeAI

r/ClaudeAI

Flashy-Preparation50

# Those of you who use Claude Code in auto-mode vs. those who don't — what's your experience?

I know some of you run Claude Code with --dangerously-skip-permissions and others won't touch it. I'm curious about both sides.

If you use auto-mode — what's your setup? Docker, VM, just raw on your local machine? Have you ever had it do something you didn't expect?

If you don't — what's holding you back? Safety concerns, unpredictable costs, or something else?

I've been thinking about this a lot because I wanted full autonomy but didn't want to risk my local machine. My solution was to run it inside ephemeral Kubernetes Pods — the agent gets full autonomy but the container is isolated and destroyed when it's done.

I ended up building an open-source tool around this called Axon. You point it at a GitHub issue and get a PR back:

axon run -p "Fix the bug in issue #42 and open a PR"

It can also watch your GitHub Issues automatically and spawn agents for each one. I use this to develop Axon itself — agents pick up our issues and submit PRs: https://github.com/axon-core/axon/blob/main/self-development/README.md

Repo including 30s demo video: https://github.com/axon-core/axon

I'm interested in hearing how everyone else is handling the autonomy question. What's working, what's not?

Is it over-engineering to run it on kubernetes?

Share

---

• Promoted

Describe what you want to build and Claude Code helps implement it, understanding how all the pieces should fit together.

Collapse video player

---

AutoModerator

2d ago

Moderator Announcement Read More »

rjyo

2d ago

I run auto-mode on my local machine but with a few guardrails. Started with Docker but the overhead was not worth it for my workflow since I mostly do app development and need access to simulators and native tooling.

My setup: I use git worktrees so Claude always works on a separate branch. If it goes off the rails I just delete the branch. The key insight for me was that most dangerous things Claude Code does are file writes and shell commands, and honestly file writes are almost never destructive if you have git. The shell commands are the real risk.

What changed my mind about auto-mode: the constant permission prompts were breaking flow. You give it a task, walk away, come back 20 minutes later and it is stuck on allow bash command three prompts deep. With auto-mode it just finishes the task.

The tradeoff is real though. I have had it rm -rf a build folder that had uncommitted generated files I needed. Nothing catastrophic but annoying. Now I just commit frequently before kicking off big tasks.

K8s feels like overkill for most solo dev workflows but I can see it making sense for a team where you are running agents on PRs automatically. Different use case than interactive development.

Flashy-Preparation50

2d ago

Thanks for sharing the use case.

So do you use auto mode almost always? How often do you use auto mode? Do you run auto mode agents in parallel?

Continue this thread

Flashy-Preparation50

2d ago

For those who don’t use auto mode at all, is it because there‘s no easy way or framework to delegate simple tasks? Or is it because you prefer to interact with coding agents?

crusoe

2d ago

I just installed Bazzite and I am getting ready to stuff Claude Code and my dev tools in a distrobox to let it run.

I wish the perm system was smart and allowed you to say "allow everything in this directory or lower automatically but everything in the parent directory or above requires approval"

crusoe

2d ago

The jail seems pretty poorly designed.

crusoe

2d ago

Distrobox is basically a container system targeted at isolated dev envs. So simpler than docker.

Flashy-Preparation50

2d ago

Do you run multiple distrobox-ed agents in parallel?

Continue this thread Continue this thread

pandavr

2d ago

If you know what you are doing, aka everything backed up, access only to some folders. You eventually can work from another PC. Then full auto-mode is a viable options.

I saw It really can go with quite complex tasks in autonomy if the starting phase was planned right.

Flashy-Preparation50

1d ago

I thought that we could just run auto-mode coding agent tasks until it fits the criteria.

Workspace is the database(git repo), and your review comments are the feedback prompt.

Continue this thread

Fyvz

1d ago

I've set up an old Mac Mini with Ubuntu, and its hosting a cloud storage service similar to dropbox. This makes it super simple to send files/folders from my laptop, and get it back when I'm done. Instead of --dangerously-skip-permissions, I allow nearly everything in ~/claude/settings.json, and deny things like rm -rf, git reset, etc. Whenever I get asked for permission, I make sure to add it to the list, so I dont get asked in the future. I know its not as unencumbered as DSP, but its a reasonable compromise: long unassisted sessions, but protection from destructive commands.

Flashy-Preparation50

1d ago

I thought that installing docker and running a kind cluster would be easier.

I am just curious... Is Kubernetes something that you don't want to adopt? Nowdays, it's super easy to run local kubernetes cluster using kind.

Fyvz

11h ago

I use podman for containers, and I like the general idea. But I've also read about agents escaping their containers. Having a spare machine to dedicate to just this purpose made it an easy choice for me.

Continue this thread Continue this thread

---

## View Post in

Português (Brasil)

हिन्दी

Français

Reddit Rules Privacy Policy User Agreement Your Privacy Choices Accessibility Reddit, Inc. © 2026. All rights reserved.


id: 313e402a3472
source_platform: reddit
author: t2_5zfmm7ga
published_at: 2026-03-11T01:00:11.422111+00:00
collected_at: 2026-03-11T01:06:15.728546+00:00
scenario_type: 工作流自动化
tools_used: ["Claude Code", "loop command", "Slack MCP", "worktree agent"]
novelty: similar
similar_to_ids: ["b2c80ce8e19d", "88a03457f4c8", "034f0f8b6fff", "7e9bc69a52f6", "93d2c2bcd5d9", "bfd43480fcf0"]
title:
https://www.reddit.com/r/ClaudeCode/comments/1rn94wp/claude_code_just_shipped_loop_schedule_recurring.json

summary:
Claude Code推出/loop命令，允许用户安排长达3天的定期任务，如自动修复PR构建问题和定时从Slack提取摘要。这个功能将Claude Code从按需工具转变为可在后台运行的个人助手，显著减少开发者的上下文切换成本。

source_url:
https://www.reddit.com/r/ClaudeCode/comments/1rn94wp/claude_code_just_shipped_loop_schedule_recurring.json

raw_content:
https://www.reddit.com/r/ClaudeCode/comments/1rn94wp/claude_code_just_shipped_loop_schedule_recurring.json

This just dropped today. Claude Code now has a `/loop` command that lets you schedule recurring tasks that run for up to 3 days.

Some of the example use cases from the announcement:

* `/loop babysit all my PRs. Auto-fix build issues and when comments come in, use a worktree agent to fix them`
* `/loop every morning use the Slack MCP to give me a summary of top posts I was tagged in`

As someone who uses Claude Code daily, the PR babysitting one is immediately useful. The amount spent context-switching to fix CI failures and address review comments is non-trivial. Having Claude just handle that in the background could be a real workflow shift.

The Slack summary one is interesting too - it's basically turning Claude Code into a personal assistant that runs on a schedule, not just a tool you invoke when you need something.

Docs here: https://code.claude.com/docs/en/scheduled-tasks

Curious what loops people come up with. What recurring tasks would you automate with this?


id: ce7a336e4c6d
title: VoltAgent/awesome-openclaw-skills
source_url: https://github.com/VoltAgent/awesome-openclaw-skills
source_platform: github
author: VoltAgent
published_at: 2026-03-10T16:34:19+00:00
collected_at: 2026-03-11T01:06:23.922444+00:00
scenario_type: 个人知识管理
tools_used: ["OpenClaw", "ClawdBot", "MoltBot"]
novelty: new
similar_to_ids: []
summary:
这是一个精心整理的OpenClaw技能库集合，汇总了5400多项从官方OpenClaw技能注册表中筛选分类的技能资源。该项目为用户提供了一个结构化的知识库，便于快速查找和利用各类AI代理技能来增强工作流程。

raw_content:
VoltAgent/awesome-openclaw-skills

The awesome collection of OpenClaw skills. 5,400+ skills filtered and categorized from the official OpenClaw Skills Registry.🦞

Topics: agent-skills, awesome, awesome-list, awesome-lists, clawd, clawdbot, clawdbot-skill, clawdhub, moltbot, moltbot-skills, openclaw, openclaw-skills
Language:  | Stars: 34501


id: 6fe122c430d7
source_url: https://www.reddit.com/r/ClaudeCode/comments/1r4k1pc/i_built_a_traffic_light_to_prevent_race/
source_platform: reddit
author: unknown
published_at: 2026-03-11T01:00:11.422115+00:00
collected_at: 2026-03-11T01:06:35.472967+00:00
scenario_type: 工作流自动化
tools_used: ["Claude Code", "OpenClaw", "Network-AI", "AuthGuardian", "Swarm Guard"]
novelty: similar
similar_to_ids: ["51d6155061d6", "7e9bc69a52f6", "93d2c2bcd5d9"]
title:
I built a "Traffic Light" to prevent race conditions when running Claude Code / Agent Swarms : r/ClaudeCode

summary:
用户开发了一个"交通灯"系统来解决多智能体并发时的竞态条件问题，通过信号量队列机制、文件系统互斥锁和权限验证层确保智能体协调运行。该方案在多智能体工作流中实现了同步控制，大幅降低了重复工作、上下文覆盖和幻觉循环的风险。

raw_content:
I built a "Traffic Light" to prevent race conditions when running Claude Code / Agent Swarms : r/ClaudeCode

I built a "Traffic Light" to prevent race conditions when running Claude Code / Agent Swarms : r/ClaudeCode Skip to main content I built a "Traffic Light" to prevent race conditions when running Claude Code / Agent Swarms : r/ClaudeCode

Go to ClaudeCode

r/ClaudeCode 22h ago

jovansstupidaccount

# I built a "Traffic Light" to prevent race conditions when running Claude Code / Agent Swarms

Hey everyone,

I’ve been diving deep into Claude Code and multi-agent setups (specifically integrating with OpenClaw), and I kept hitting a major bottleneck: Race Conditions.

When you have multiple agents or sub-agents running fast (especially with the new 3.7 Sonnet), they tend to "talk over" each other—trying to edit files or update context simultaneously. This leads to:

Duplicate work (two agents picking up the same task).

Context overwrites (Agent A deletes Agent B's memory).

Hallucination loops.

I built a lightweight "Traffic Light" system (Network-AI) to fix this.

What it does: It acts as a semaphore for your swarm. It forces agents to "queue" for critical actions (like file writes or API calls) so the context remains stable. It kills the concurrency bugs without slowing down the workflow too much.

The Repo: https://github.com/jovanSAPFIONEER/Network-AI

I added specific support for OpenClaw as well. If anyone else is building swarms with Claude Code and hitting these coordination issues, I’d love to hear if this helps stabilize your run.

feedback welcome! 🚦

Read more

Share

---

Otherwise_Wave9374

22h ago

This is a super practical fix, concurrency bugs are the one thing that make multi-agent setups feel "random". The semaphore/queue idea makes a lot of sense, especially around file writes and shared context.

Curious, do you also guard tool calls (like external APIs) or just the repo workspace + memory layer?

I have been collecting patterns for coordinating agent swarms (locks, leases, task claiming, etc) and a few notes here were helpful: https://www.agentixlabs.com/blog/

1

jovansstupidaccount

22h ago

Workspace/memory layer: The blackboard uses file-system mutexes with atomic commits (propose → validate → commit). Two agents can't write to the same key simultaneously -- the second one gets a conflict.

External API/tool calls: The AuthGuardian acts as a permission wall in front of any resource type -- DATABASE, PAYMENTS, EXTERNAL_SERVICE, EMAIL, SAP_API, etc. Before an agent can hit an external API, it has to request permission with a justification. The system scores it (trust level + risk + justification quality) and either grants a time-limited token with restrictions (rate limits, read-only, max records) or denies it. So it's not intercepting the HTTP call itself, but gating whether the agent is allowed to make it and under what constraints.

The budget tracking layer (Swarm Guard) also caps total token spend across the swarm, so even if 5 agents run in parallel, combined cost can't exceed the ceiling.

That blog looks interesting -- I'll check it out. Always looking at how others handle the leasing/task-claiming side of things. If you see anything that could plug into this, happy to discuss.

1

jovansstupidaccount

22h ago

i am definitely going to solve this issue in the next phase

1

jovansstupidaccount

21h ago

also thanks you for this :)

1

New-fone_Who-Dis

21h ago

Its an ai bot built to market its sites. Macromind seems to be the real account holder.

Possible sockpuppet / undisclosed self-promo pattern: user “Otherwise_Wave9374” repeatedly seeds agentixlabs.com/blog in comments (of their last 1100 comments, almost all of them either link to one of the 2 below urls, thats over 500 for each url; user “macromind” promotes promarkia.com and also links agentixlabs.com/blog in some threads. Suggests same project/funnel using multiple accounts. Please review for spam/self-promo policy. Its using AI to make it somewhat relevant to whatever the post is about, take this one for example, its read AI in the posters username, yet the sub is for father's rights and has nothing to do woth ai agents etc - https://www.reddit.com/r/FathersRights/s/xMFCqCJjKi

Here's another post where it went haywire commenting multiple times - https://www.reddit.com/r/UGCcreators/s/NqS346kBAu

1

Continue this thread Continue this thread

jovansstupidaccount

21h ago

Wait so is it fake or real the person who replied to me

1

---

## View Post in

Português (Brasil)

Français

Reddit Rules Privacy Policy User Agreement Your Privacy Choices Accessibility Reddit, Inc. © 2026. All rights reserved.


id: d3a49d8714eb
title: Claude Code's plan mode changed how I hand off work to my dev team : r/ClaudeCode
source_url: https://www.reddit.com/r/ClaudeCode/comments/1r8d2gs/claude_codes_plan_mode_changed_how_i_hand_off/
source_platform: reddit
author: unknown
published_at: 2026-03-11T01:00:11.422118+00:00
collected_at: 2026-03-11T01:06:59.257271+00:00
scenario_type: 工作流自动化
tools_used: ["Claude Code", "plan mode"]
novelty: similar
similar_to_ids: ["313e402a3472", "51d6155061d6", "a44c7aa65560", "97dcab4759c8"]
summary:
用户利用Claude Code的计划模式改进了团队工作交接流程，通过生成详细的技术方案来减少沟通障碍和歧义。该方法特别适用于复杂的跨层级代码变更，能加速开发人员的上手速度和架构理解，同时在PR审查中帮助发现实现与原意的偏差。

raw_content:
Claude Code's plan mode changed how I hand off work to my dev team : r/ClaudeCode

Claude Code's plan mode changed how I hand off work to my dev team : r/ClaudeCode Skip to main content Claude Code's plan mode changed how I hand off work to my dev team : r/ClaudeCode

Go to ClaudeCode

r/ClaudeCode 22h ago

hurrah-dev

# Claude Code's plan mode changed how I hand off work to my dev team

I've been using Claude Code for a while now, and the feature that's had the biggest impact isn't code generation - it's plan mode.

My workflow now: I take a spec or feature request, feed it into Claude in plan mode, and get back a detailed technical plan - specific files, logic flow, edge cases, the works. I hand that to my developer instead of my usual "here's what I need, figure out the approach" handoff.

Result: way fewer back-and-forth cycles, less ambiguity, faster turnaround.

The other side that surprised me: PR reviews. I feed Claude the original plan alongside the PR diff. It flags where implementation drifted from intent, catches stuff I'd miss on a late-night review, and gives me a structured way to evaluate the work.

Not replacing anyone - just removing the translation loss between what I want built and what actually gets built.

Curious if anyone else is using plan mode this way, or if you've found other non-obvious workflow wins with AI coding tools.

Share

---

• Promoted

Subscribe to Z.ai for fast, affordable coding AI with GLM models and MIT license.

---

Mopezz

22h ago

Why don’t you give your devs the feature spec and they feed it into into plan mode themselves.

Assuming you’re not techy, they can actually plan with Claude, catch wrong implications and steer it to a plan that is well thought.

If you are actually techy yourself, you‘re also a micro manager now, hindering your devs from growth, and essentially a human interface for Claude. Good job.

2

hurrah-dev

21h ago

Fair pushback, but I think you're imagining a simpler codebase than what we're working with.

This isn't for straightforward feature work. Our codebase has legacy .NET 4.8 WebForms, a newer .NET 10 Minimal API with a feature-based folder structure, multi-tenant architecture, and decades of accumulated business logic. When a developer picks up a large-scale change that cuts across those layers, the ramp-up time used to be significant - lots of "where does this live?" and "how does this connect to that?" conversations.

Plan mode compresses that. The developer gets a map of the codebase relevant to the task, and they learn the architecture as they implement instead of needing weeks of guided onboarding. They still make every technical decision and write all the code.

For small changes? Yeah, they absolutely just pick it up and run. This is specifically for the complex stuff where context matters more than skill.

0

laluneodyssee

20h ago

But you're not setting them up for success at all if you're just giving them direct instructions as to what to do.

1

Continue this thread

The_Noble_Lie

21h ago

Yes the plan is iterative and should be version controlled. Whether Human A or B iterates on it is variable. But usually it's comes from "someone more experienced" in some shops (in software architecture)

Now, I just prefer to work alone. But at times it feels like I'm working with human-ish phantoms.

1

Continue this thread

taldbek

22h ago

I do something very similar, but I have cc write the plan and create the issue, then let cc implement it, then cc reviews the pr. For the vast majority of straight forward bugs and features it is amazing and would slot into any team. It is coordinated via GitHub actions and directed via comments on issues/PRs.

1

hurrah-dev

21h ago

That's a great setup. I like the idea of coordinating it through GitHub Actions and issue/PR comments - keeps everything traceable. For straightforward bugs and features that's a solid workflow. I tend to stay more hands-on with the plan review step myself, but that's partly because our codebase has a mix of legacy .NET 4.8 WebForms and a newer .NET 10 API, so the plans need context that's hard to automate away. Curious how complex the features are that you're running fully automated like that?

2

taldbek

17h ago

Thanks! At work? I'm very conservative with it but with relatively isolated and well planned tasks I'm comfortable w/ Claude doing the work w/ a human review. E.g. < 6 files or so.

On my hobby project, which is much smaller at ~40k lines of Python, I go ham. I'll have it do huge tasks unsupervised just to see what happens. Again, planning is key. I had it do one refactor task that was intentionally _way_ too big -- ~12k lines modified using the new agent teams. And the broad strokes worked. It introduced a bunch of bugs in the process that I had to clean up over the next day or so but the fact that it produced mostly functional code was impressive. Obviously, not recommended.

Another thing I noticed is saying "Spawn a staff engineer sub-agent to review this plan and apply the changes" can find some significant oversights. Doing that twice in a row before a manual review is helpful, the third time gives diminishing returns.

1

Continue this thread Continue this thread

byte-array

20h ago

I found that sharing the plan is great for alignment. But I’m curious: Why don’t you run the plan yourself on your Claude code?

1

hurrah-dev

20h ago

For my own builds I do exactly that. But when handing off large-scale changes, the plan is a starting point, not a complete instruction set. There's judgment calls, edge cases that only surface during implementation, and testing that needs to happen along the way. A developer catches things mid-build that no plan anticipates - "this breaks the existing sync method" or "this assumption doesn't hold for multi-tenant clients." I need a human thinking critically through the implementation, not just executing steps.

2

Continue this thread

Silvio1905

20h ago

the magic happens when you let people to figure out the best way to do things and be creative

1

---

## View Post in

Français

Reddit Rules Privacy Policy User Agreement Your Privacy Choices Accessibility Reddit, Inc. © 2026. All rights reserved.


id: 53514a186429
title: How to run claude code contionously till the task is complete : r/ClaudeCode
source_platform: reddit
author: unknown
published_at: 2026-03-11T01:00:11.422125+00:00
collected_at: 2026-03-11T01:07:20.010309+00:00
scenario_type: 工作流自动化
tools_used: ["Claude Code", "Ralph Loop", "get-shit-done", "superpowers", "Claude Agent Teams"]
novelty: similar
similar_to_ids: ["313e402a3472", "034f0f8b6fff", "7e9bc69a52f6", "93d2c2bcd5d9"]
summary:
用户寻求通过Claude Code自动化完整的软件开发生命周期流程，包括需求收集、实现、测试、提交和代码审查等多个阶段。讨论了利用Ralph Loop、get-shit-done等工具和Claude Agent Teams来实现跨上下文的连续任务执行，解决长任务中上下文溢出导致质量下降的问题。

source_url:
https://www.reddit.com/r/ClaudeCode/comments/1r4kdfk/how_to_run_claude_code_contionously_till_the_task/

raw_content:
How to run claude code contionously till the task is complete : r/ClaudeCode

How to run claude code contionously till the task is complete : r/ClaudeCode Skip to main content How to run claude code contionously till the task is complete : r/ClaudeCode

Go to ClaudeCode

r/ClaudeCode 16h ago

SodhiMoham

# How to run claude code contionously till the task is complete

So i have custom skills for eveerything

right from gathering requirements -> implement -> test -> commit -> security review + perf review -> commit -> pr

i just want to start a session with a requirement, and it has to follow these skills in order and do things end to end

but my problem is context will run out in the middle, and i am afraid once it happens, the quality drops

how do i go about this?

one approach is obviously, manually clearing contexts or restarting sessions and telling it manually

Share

---

• Promoted

Watch Claude Code write firmware and mobile code. No bouncing between IDEs. No issues with integrations. Just straight to a working solution.

Collapse video player

---

mikeb550

16h ago

Watch youtube videos for the Ralph Loop.

14

Sleepnotdeading

15h ago

This is what you want. A Ralph loop is a recursive bash loop that will work through a markdown file executing one task per context loop. Here’s the original GitHub repo by Geoff Huntley. Show it to Claude and it will help you set it up. https://github.com/ghuntley/how-to-ralph-wiggum

6

SodhiMoham

16h ago

i will check it out, just curious does it work with custom skills?

2

BootyMcStuffins

16h ago

It’s a pattern. It works with whatever tools you want

3

Continue this thread 1 more reply

Continue this thread

256BitChris

16h ago

What you want is this:

https://github.com/gsd-build/get-shit-done

It will manage your context and go from prompt to validated delivered project after having a few design or planning questions - writes everything out to md, splits context, etc.

Will run for hours so don't use without a Max 20 plan if you're doing anything serious.

Honestly, this is something that needs to be talked about more - this guy managed to make Claude Code into a complete software development lifecycle machine, just with prompt files. It's got nice outputs, always does what it's told - worth studying just to learn how to write your own 'programs' with Claude Code.

23

Formal_Bat_3109

15h ago

I tried this for a huge code base and it ran out of context when I asked it to analyse a monorepo. I use https://github.com/obra/superpowers instead

7

Dennis-veteran

16h ago

This looks interesting, I will take a look

2

SodhiMoham

15h ago

Thanks for pointing this to me

looks like i need to still type commands /gsd:plan-phase 1, /gsd:execute-phase 1 manually

what if i want to do all this automatically?

hear me out:

with the new claude agent teams my ideal workflow would want to be something like this

an architect and product manager agents converge on the architecture

then an implementor spawns and implements

qa executes the tests, gives the feedback to implementor

implementor implements it, and so on

but here, i want these agents to use the skills i have, and i want them to take the decisions themselves, align and document and move on to next step

is it possible in the get shit done?

1

DifferenceTimely8292

14h ago

Ideal workflow doesn’t mean ideal output… you can try to one shot everything but it won’t be optimum output. You want to iterate over small details to the extent, branching strategy, architecture, loggin, secret mgmt, fail over. Before you get to application logic

2

cannontd

14h ago

Paste your post here into Claude with the words “can you make a skill that does:” in front of it. The output will be wild.

3

2 more replies

Continue this thread 3 more replies

Continue this thread

EternalStudent07

15h ago

Seems like that goal/process is a bad plan/method. That keeping the same context for testing as you used for creating the possibly bad code leads to problems.

https://agenticoding.ai/docs/faq#can-ai-agents-review-their-own-generated-code

https://agenticoding.ai/docs/faq#how-do-i-validate-ai-generated-code-efficiently

Basically by reusing the context you're maintaining possibly faulty assumptions or reasoning. Like always asking the creator of a change to be the only QA/test person to review and validate it. "Why yes, I did great work. Ship it!"

It looks like you'll want to create separate workers that repeatedly perform the same types of works (steps in the process you listed). Moving tasks up or down the chain as appropriate. Letting each task type start fresh, using saved context from the previous work.

3

• Promoted

Stop babysitting terminals. Manage a team of agents from a doc. Try Tonkotsu FREE.

joshman1204

16h ago

Not sure what the easiest method is but I had a very similar system and ran into the same problems. I migrated all of my skills into a LangGraph system and it has been amazing. You can still use your subscription billing so no api fees but you gain much better control. Each step of your process just becomes a node in the graph and it fires a new Claude session for each step so no context problems. You just need to be careful with your prompts and state management to make sure you are giving the proper context to each claude call at each step.

5

2 more replies

Continue this thread

_Bo_Knows

14h ago

You want this: https://github.com/boshu2/agentops

I’ve done what you said: Made atomic skills for each step, chained them together, added hooks for enforcement. Also have an /evolve skill that auto runs the /rpi loops towards a goal

“ One command ships a feature end-to-end — researched, planned, validated by multiple AI models, implemented in parallel, and the system remembers what it learned for next time. The difference isn't smarter agents — it's controlling what context enters each agent's window at each phase, so every decision is made with the right information and nothing else. Every session compounds on the last. You stop managing your agent and start managing your roadmap.”

2

1 more reply

Continue this thread

rubyonhenry

13h ago

This works well for me https://github.com/hl/loop/

2

tuple32

13h ago

I never let a task take more than 70% of context. You or your task creation or planning agent need to create a plan with small individual tasks. You or your agent need to review it carefully to make sure they are workable and not too big. You can save the plan as a markdown file, and let each agent pick it up.

2

samyakagarkar

13h ago

Use Ralph Wiggum plugin for Claude code. It has max iterations parameter. You can set it to high like 50. Claude code will keep trying for 50 times till it gets the completion tag. So it's good. Exactly what you want

2

imedwardluo

12h ago

look into Ralph Loop - it's built for this.

official Claude Code plugin exists, but Ryan's version is more production-ready: https://github.com/snarktank/ralph/

it splits tasks via prd.json, tracks progress in progress.txt, and handles context limits by checkpointing each phase. I've used it for overnight builds.

2

electricshep

11h ago

Just use agent teams https://code.claude.com/docs/en/agent-teams

2

• Promoted

Dev Sandbox Made for AI Coding

BlackAtomXT

9h ago

Have the entire plan complete in an md file.

Enable teams, assign a team leader to the team, their one goal is ensuring that the entire implementation is complete so you tell them to start by reading the file. Assign implementers, I find it's good at picking the right number of implementers if you ask it to break it into manageable portions. Give it a QA and a code reviewer, task them both as you see fit for the desired outcome and be amazed. The team leader will make sure it gets done!

Claude teams will hoover up tokens like nobodies business but it's on another level in terms of getting huge tasks done auntomously. I hooked it into our issue system and it was just burning it's way through issues, just like it was burning through tokens. A couple moderate sized features and several tickets done in a few hours, and my Claude Max 20x was spent. I have it building tools so I can run as many concurrent max accounts as possible and centralizing it all into a single web control panel where I can visualize it completing tasks. I'm having so much fun rendering myself redundant right now.

2

1 more reply

Continue this thread

cannontd

16h ago

You need to structure your codebase and workflow so that needing a context full of info is not needed for it to be correct.

Look at spec driven workflows and read all of https://agenticoding.ai/

1

1 more reply

Continue this thread

Chillon420

15h ago

Create a Claude MD Skill and let it write instructions to handle Agenteams. Enable Agenteams. Including a PM Agent. Then create Scope based context like epics and us in Md files and let Claude work on it. my maximum was at 9h30 where it worked autonomous.

1

1 more reply

Continue this thread

leogodin217

15h ago

Like others have said, gsd, openspec, speck-kitty, etc. are good. If you want to roll your own, ask Claude to help you create the /commands. Make sure they are using custom subagents and have rules for context-efficient interactions between them. Custom subagents have their own context windows.

That being said, it's difficult with Opus 4.6. It eats a lot of context. You can play with /commands and CLAUDE.md to reduce it. Switching to Sonnet uses less context, but I find that it never wants to finish. It will randomly stop and ask for feedback. Or say context is running low when it is at like 30%.

The key is having one command act as the orchestrator. That way, if context gets bloated, it isn't screwing up the work. Let the subagents do the work and report back to the orchestrator.

1

YUL438

12h ago

use the official plugin https://github.com/anthropics/claude-code/tree/main/plugins/ralph-wiggum

1

---

## View Post in

Português (Brasil)

Reddit Rules Privacy Policy User Agreement Your Privacy Choices Accessibility Reddit, Inc. © 2026. All rights reserved.


id: 76a435bcb8ee
title: bytedance/UI-TARS-desktop
summary: 字节跳动开源的多模态AI代理框架，通过连接先进的AI模型和代理基础设施，实现GUI自动化和浏览器操作。该项目支持视觉语言模型、MCP协议和计算机控制，可用于构建自动化工作流和智能代理系统。
source_url: https://github.com/bytedance/UI-TARS-desktop
source_platform: github
author: bytedance
published_at: 2026-03-10T11:40:44+00:00
collected_at: 2026-03-11T01:07:58.039171+00:00
scenario_type: 工作流自动化
tools_used: ["UI-TARS", "MCP", "Browser-use", "Computer-use", "VLM", "GUI Agent"]
novelty: similar
similar_to_ids: ["cebb6abe12ab", "51d6155061d6", "6885ba6c5ca2", "5471379ee4ff", "97dcab4759c8"]
raw_content:
bytedance/UI-TARS-desktop

The Open-Source Multimodal AI Agent Stack: Connecting Cutting-Edge AI Models and Agent Infra

Topics: agent, agent-tars, browser-use, computer-use, cowork, gui-agent, gui-operator, mcp, mcp-server, multimodal, tars, ui-tars, vision, vlm
Language: TypeScript | Stars: 28697


id: f0452d349dc5
title: Show HN: I built a tool that watches webpages and exposes changes as RSS
source_url: https://sitespy.app
source_platform: hackernews
author: vkuprin
published_at: 2026-03-11T16:21:06+00:00
collected_at: 2026-03-12T01:00:40.161327+00:00
scenario_type: 工作流自动化
novelty: similar
similar_to_ids: ["df11630e65be", "5471379ee4ff", "c37165a31cd3"]
summary:
Site Spy是一款网页变化监控工具，可以追踪特定网页元素的更新并通过RSS、邮件、Telegram等方式推送通知。该工具集成了浏览器扩展、Web仪表板和MCP服务器，支持差异对比和快照历史查看，适用于监控价格、库存、政策变更等重要信息的自动化场景。

tools_used:
["Site Spy", "Chrome Extension", "Firefox Extension", "RSS Feed", "MCP Server", "Telegram", "Email Notifications"]

raw_content:
Show HN: I built a tool that watches webpages and exposes changes as RSS

I built Site Spy after missing a visa appointment slot because a government page changed and I didn’t notice for two weeks.<p>It watches webpages for changes and shows the result like a diff. The part I think HN might find interesting is that it can monitor a specific element on a page, not just the whole page, and it can expose changes as RSS feeds.<p>So instead of tracking an entire noisy page, you can watch just a price, a stock status, a headline, or a specific content block. When it changes, you can inspect the diff, browse the snapshot history, or follow the updates in an RSS reader.<p>It’s a Chrome&#x2F;Firefox extension plus a web dashboard.<p>Main features:<p>- Element picker for tracking a specific part of a page<p>- Diff view plus full snapshot timeline<p>- RSS feeds per watch, per tag, or across all watches<p>- MCP server for Claude, Cursor, and other AI agents<p>- Browser push, Email, and Telegram notifications<p>Chrome: <a href="https:&#x2F;&#x2F;chromewebstore.google.com&#x2F;detail&#x2F;site-spy&#x2F;jeapcpanagdgipcfnncmogeojgfofige" rel="nofollow">https:&#x2F;&#x2F;chromewebstore.google.com&#x2F;detail&#x2F;site-spy&#x2F;jeapcpanag...</a><p>Firefox: <a href="https:&#x2F;&#x2F;addons.mozilla.org&#x2F;en-GB&#x2F;firefox&#x2F;addon&#x2F;site-spy&#x2F;" rel="nofollow">https:&#x2F;&#x2F;addons.mozilla.org&#x2F;en-GB&#x2F;firefox&#x2F;addon&#x2F;site-spy&#x2F;</a><p>Docs: <a href="https:&#x2F;&#x2F;docs.sitespy.app" rel="nofollow">https:&#x2F;&#x2F;docs.sitespy.app</a><p>I’d especially love feedback on two things:<p>- Is RSS actually a useful interface for this, or do most people just want direct alerts?<p>- Does element-level tracking feel meaningfully better than full-page monitoring?


id: 383475726b14
title: Show HN: Klaus – OpenClaw on a VM, batteries included
source_url: https://klausai.com/
source_platform: hackernews
author: robthompson2018
published_at: 2026-03-11T15:54:23+00:00
collected_at: 2026-03-12T01:00:51.079302+00:00
scenario_type: 商业流程自动化
novelty: similar
similar_to_ids: ["a6ba47795183"]
summary:
Klaus是一个托管的OpenClaw平台服务,为用户提供预配置的EC2实例来运行AI代理工具,解决了本地部署的安全性和复杂性问题。该项目包含自动修复系统ClawBert(基于Claude Code的AI SRE),以及Slack和Google Workspace等主流应用的OAuth集成,面向需要可靠AI代理基础设施的商业用户。

tools_used:
["OpenClaw", "Claude Code", "EC2", "AWS", "OpenRouter", "AgentMail", "Orthogonal", "Slack", "Google Workspace", "Kimi K2.5", "Mimimax M2.5", "Opus 4.6"]

raw_content:
Show HN: Klaus – OpenClaw on a VM, batteries included

We are Bailey and Robbie and we are working on Klaus (<a href="https:&#x2F;&#x2F;klausai.com&#x2F;" rel="nofollow">https:&#x2F;&#x2F;klausai.com&#x2F;</a>): hosted OpenClaw that is secure and powerful out of the box.<p>Running OpenClaw requires setting up a cloud VM or local container (a pain) or giving OpenClaw root access to your machine (insecure). Many basic integrations (eg Slack, Google Workspace) require you to create your own OAuth app.<p>We make running OpenClaw simple by giving each user their own EC2 instance, preconfigured with keys for OpenRouter, AgentMail, and Orthogonal. And we have OAuth apps to make it easy to integrate with Slack and Google Workspace.<p>We are both HN readers (Bailey has been on here for ~10 years) and we know OpenClaw has serious security concerns. We do a lot to make our users’ instances more secure: we run on a private subnet, automatically update the OpenClaw version our users run, and because you’re on our VM by default the only keys you leak if you get hacked belong to us. Connecting your email is still a risk. The best defense I know of is Opus 4.6 for resilience to prompt injection. If you have a better solution, we’d love to hear it!<p>We learned a lot about infrastructure management in the past month. Kimi K2.5 and Mimimax M2.5 are extremely good at hallucinating new ways to break openclaw.json and otherwise wreaking havoc on an EC2 instance. The week after our launch we spent 20+ hours fixing broken machines by hand.<p>We wrote a ton of best practices on using OpenClaw on AWS Linux into our users’ AGENTS.md, got really good at un-bricking EC2 machines over SSM, added a command-and-control server to every instance to facilitate hotfixes and migrations, and set up a Klaus instance to answer FAQs on discord.<p>In addition to all of this, we built ClawBert, our AI SRE for hotfixing OpenClaw instances automatically: <a href="https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=v65F6VBXqKY" rel="nofollow">https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=v65F6VBXqKY</a>. Clawbert is a Claude Code instance that runs whenever a health check fails or the user triggers it in the UI. It can read that user’s entries in our database and execute commands on the user’s instance. We expose a log of Clawbert’s runs to the user.<p>We know that setting up OpenClaw is easy for most HN readers, but I promise it is not for most people. Klaus has a long way to go, but it’s still very rewarding to see people who’ve never used Claude Code get their first taste of AI agents.<p>We charge $19&#x2F;m for a t4g.small, $49&#x2F;m for a t4g.medium, and $200&#x2F;m for a t4g.xlarge and priority support. You get $15 in tokens and $20 in Orthogonal credits one-time.<p>We want to know what you are building on OpenClaw so we can make sure we support it. We are already working with companies like Orthogonal and Openrouter that are building things to make agents more useful, and we’re sure there are more tools out there we don’t know about. If you’ve built something agents want, please let us know. Comments welcome!


id: 9d622833f3fc
title: Claude Sonnet 4.6 OpenClaw Setup: Stop Overpaying For Multi-Step Automation : r/AISEOInsider
source_platform: reddit
author: unknown
published_at: 2026-03-12T01:00:14.213094+00:00
collected_at: 2026-03-12T01:01:01.003245+00:00
scenario_type: 工作流自动化
tools_used: ["Claude Sonnet 4.6", "OpenClaw"]
novelty: similar
similar_to_ids: ["93d2c2bcd5d9", "b2c80ce8e19d", "88a03457f4c8", "034f0f8b6fff"]
summary:
本文介绍了使用Claude Sonnet 4.6与OpenClaw本地框架组合来降低多步骤AI自动化成本的方案。通过在本地运行OpenClaw执行层，该设置实现了可持续的代理工作流程，避免了多轮token调用导致的成本累积问题，特别适合文档解析、网页导航和代码执行等日常自动化任务。

source_url:
https://www.reddit.com/r/AISEOInsider/comments/1rcml5y/claude_sonnet_46_openclaw_setup_stop_overpaying/

raw_content:
Claude Sonnet 4.6 OpenClaw Setup: Stop Overpaying For Multi-Step Automation : r/AISEOInsider

Claude Sonnet 4.6 OpenClaw Setup: Stop Overpaying For Multi-Step Automation : r/AISEOInsider Skip to main content Claude Sonnet 4.6 OpenClaw Setup: Stop Overpaying For Multi-Step Automation : r/AISEOInsider

Go to AISEOInsider

r/AISEOInsider 1d ago

JamMasterJulian

# Claude Sonnet 4.6 OpenClaw Setup: Stop Overpaying For Multi-Step Automation

Claude Sonnet 4.6 OpenClaw Setup is the combination that finally makes AI agents affordable enough to run consistently instead of cautiously.

Most people are massively overpaying for automation because they default to the most expensive model for tasks that simply do not require it.

Multi-step agents multiply token usage quietly, which turns that default choice into a recurring financial leak.

Watch the video below:

https://www.youtube.com/watch?v=g3PvB7LhXqM&t=3s

Want to make money and save time with AI? Get AI Coaching, Support & Courses👉 https://www.skool.com/ai-profit-lab-7462/about

# Claude Sonnet 4.6 OpenClaw Setup Solves The Hidden Token Trap

Claude Sonnet 4.6 OpenClaw Setup matters because agents are loops, not single prompts.

Each workflow involves planning, executing, observing, adjusting, and sometimes retrying.

Every loop consumes tokens, and those tokens stack up fast in real-world usage.

OpenClaw is built to execute actions across software environments, which means the model is called repeatedly during one task.

That repetition is what makes the wrong model choice expensive.

Claude Sonnet 4.6 OpenClaw Setup lowers the cost per step so the full loop becomes sustainable.

Sustainable agents get used more often.

Frequent usage is what creates actual leverage.

# OpenClaw As The Action Layer In Claude Sonnet 4.6 OpenClaw Setup

OpenClaw runs locally and gives you full control over the agent environment.

Instead of paying for a hosted execution layer, you manage permissions and workflows directly on your machine.

Messages trigger browsing, file edits, code execution, structured extraction, and multi-step automation.

That difference between chat and action is everything.

Chat gives answers.

Agents deliver outcomes.

Claude Sonnet 4.6 OpenClaw Setup connects a capable reasoning model to a system that can actually implement decisions.

Reasoning without execution is limited.

Execution without smart reasoning is chaotic.

This setup balances both.

# Why Claude Sonnet 4.6 Makes Claude Sonnet 4.6 OpenClaw Setup Practical

Claude Sonnet 4.6 OpenClaw Setup works because performance remains close enough to higher-tier models for everyday tasks.

Most automation jobs involve document parsing, web navigation, spreadsheet interaction, structured summaries, and moderate coding.

These tasks require stable reasoning across multiple steps, not extreme reasoning depth.

Claude Sonnet 4.6 handles those workflows reliably while keeping token pricing manageable.

When cost drops but capability remains strong, hesitation disappears.

Claude Sonnet 4.6 OpenClaw Setup turns agents from “occasionally useful” into “daily infrastructure.”

# Real-Use Performance In Claude Sonnet 4.6 OpenClaw Setup

Claude Sonnet 4.6 OpenClaw Setup shines in practical environments where agents interact with real software.

Navigating browsers, filling forms, reading PDFs, and manipulating spreadsheets are multi-step tasks.

In these environments, the performance gap between mid-tier and top-tier models narrows significantly.

Consistency across steps matters more than headline benchmark dominance.

Claude Sonnet 4.6 delivers that consistency at a fraction of the cost.

Close-enough performance combined with lower pricing changes how often you deploy automation.

Frequency is what compounds results.

# Security And Stability In Claude Sonnet 4.6 OpenClaw Setup

Claude Sonnet 4.6 OpenClaw Setup also benefits from stronger resistance to prompt injection attacks.

Agents that browse the web can encounter malicious content attempting to redirect instructions.

Improved resilience reduces the risk of unintended behavior.

OpenClaw allows permission control, ensuring agents operate within defined boundaries.

Pairing that with a model that handles adversarial content more cautiously improves reliability.

Lower cost is useful.

Reliable execution is essential.

Claude Sonnet 4.6 OpenClaw Setup delivers both.

# How To Approach Claude Sonnet 4.6 OpenClaw Setup Step By Step

Claude Sonnet 4.6 OpenClaw Setup works best when implemented gradually.

Install OpenClaw and confirm your local runtime is stable before scaling.

Configure your API key and set Claude Sonnet 4.6 as the default model.

Start with a single recurring workflow that already consumes your time each week.

Observe how the agent plans and executes.

Refine instructions to tighten scope and reduce unnecessary steps.

Reusable templates prevent repeated token waste.

Claude Sonnet 4.6 OpenClaw Setup becomes more efficient as structure improves.

Structure reduces loops.

Fewer loops reduce cost.

Lower cost encourages consistency.

# Long-Term Economics Of Claude Sonnet 4.6 OpenClaw Setup

Claude Sonnet 4.6 OpenClaw Setup compounds savings because multi-step workflows amplify pricing differences.

Premium pricing multiplies quickly when tasks involve dozens of reasoning calls.

Affordable pricing makes daily repetition viable.

Running a 20-step workflow each weekday at a lower rate drastically changes monthly spending.

Claude Sonnet 4.6 OpenClaw Setup transforms automation from an occasional experiment into an operational habit.

Habits generate predictable output.

Predictable output drives measurable growth.

# When To Escalate Beyond Claude Sonnet 4.6 OpenClaw Setup

Claude Sonnet 4.6 OpenClaw Setup is not a claim that premium models are obsolete.

Deep architectural reasoning, advanced research synthesis, or complex long-horizon planning may still justify higher-tier models.

The smarter strategy is to default to Sonnet for everyday automation and escalate only when complexity demands it.

Default selection defines baseline cost.

Selective escalation preserves quality.

Claude Sonnet 4.6 OpenClaw Setup works best when model choice becomes intentional rather than automatic.

# Who Gains The Most From Claude Sonnet 4.6 OpenClaw Setup

Claude Sonnet 4.6 OpenClaw Setup fits developers running multiple automation pipelines in parallel.

Solo operators benefit because routine admin tasks become affordable to automate daily.

Small teams gain confidence experimenting with agents without fearing runaway API bills.

Anyone seeking to treat agents as infrastructure rather than novelty will find this setup practical.

Infrastructure scales.

Experiments do not.

Claude Sonnet 4.6 OpenClaw Setup is built for scale.

# Workflow Discipline In Claude Sonnet 4.6 OpenClaw Setup

Claude Sonnet 4.6 OpenClaw Setup still requires structured prompting.

Clear objectives prevent wandering behavior.

Defined constraints reduce unnecessary reasoning loops.

Reusable templates stabilize recurring workflows.

Each improvement reduces token waste and increases reliability.

Efficiency compounds when workflows remain clean and repeatable.

Claude Sonnet 4.6 OpenClaw Setup becomes stronger as discipline increases.

# The Bigger Pattern Behind Claude Sonnet 4.6 OpenClaw Setup

Claude Sonnet 4.6 OpenClaw Setup reflects a broader trend in AI.

Mid-tier models are closing the gap for practical use cases.

As that gap shrinks, pricing becomes the key differentiator for everyday automation.

Choosing a cost-efficient default model today compounds savings over months of usage.

Claude Sonnet 4.6 OpenClaw Setup places you on the efficient side of that shift.

Long-term decisions outperform short-term hype.

# The AI Success Lab — Build Smarter With AI

👉 https://aisuccesslabjuliangoldie.com/

Inside, you’ll get step-by-step workflows, templates, and tutorials showing exactly how creators use AI to automate content, marketing, and workflows.

It’s free to join — and it’s where people learn how to use AI to save time and make real progress.

If you want to explore the full OpenClaw guide, including detailed setup instructions, feature breakdowns, and practical usage tips, check it out here: https://www.getopenclaw.ai/

# Frequently Asked Questions About Claude Sonnet 4.6 OpenClaw Setup

Is Claude Sonnet 4.6 OpenClaw Setup truly cost-efficient for agents? Yes, because multi-step agent workflows multiply token usage and lower per-token pricing compounds savings rapidly.

Does Claude Sonnet 4.6 OpenClaw Setup replace premium models entirely? No, premium models remain valuable for extreme reasoning tasks, but Sonnet handles most daily workflows effectively.

What types of tasks are best suited for Claude Sonnet 4.6 OpenClaw Setup? Document processing, web interaction, structured summaries, spreadsheet manipulation, and routine coding are strong fits.

How can costs remain predictable within Claude Sonnet 4.6 OpenClaw Setup? Clear objectives, structured prompts, and reusable workflow templates reduce unnecessary token consumption.

What is the recommended starting approach for Claude Sonnet 4.6 OpenClaw Setup? Install OpenClaw locally, configure Sonnet 4.6 as the default model, test one recurring workflow, then scale gradually based on reliability and cost behavior.

Read more

Share

---

• Promoted

Try creating a mini me with ChatGPT Images.

---

Reddit Rules Privacy Policy User Agreement Accessibility Reddit, Inc. © 2026. All rights reserved.


id: cea09b937893
title: Show HN: Open-source browser for AI agents
source_url: https://github.com/theredsix/agent-browser-protocol
source_platform: hackernews
author: theredsix
published_at: 2026-03-11T14:39:30+00:00
collected_at: 2026-03-12T01:01:11.502088+00:00
scenario_type: 终端与CLI增强
tools_used: ["agent-browser-protocol", "Chromium", "Claude MCP", "Playwright", "Claude Opus 4.6"]
novelty: similar
similar_to_ids: ["ba31bde2dfc2", "abb1b9505bb9"]
summary:
这是一个针对AI代理的开源浏览器工具，通过冻结JavaScript执行和渲染来保持代理与浏览器状态同步，解决了传统浏览器自动化中的多个常见问题。该工具与Claude通过MCP协议集成，使得AI与网页交互更像多轮对话，在Online Mind2Web基准测试中达到90.5%的准确率。

raw_content:
Show HN: Open-source browser for AI agents

Hi HN, I forked chromium and built agent-browser-protocol (ABP) after noticing that most browser-agent failures aren’t really about the model misunderstanding the page. Instead, the problem is that the model is reasoning from a stale state.<p>ABP is designed to keep the acting agent synchronized with the browser at every step. After each action (click, type, etc), it freezes JavaScript execution and rendering, then captures the resulting state. It also compiles the notable events that occurred during that action loop, such as navigation, file pickers, permission prompts, alerts, and downloads, and sends that along with a screenshot of the frozen page state back to the agent.<p>The result is that browser interaction starts to feel more like a multimodal chat loop. The agent takes an action, gets back a fresh visual state and a structured summary of what happened, then decides what to do next from there. That fits much better with how LLMs already work.<p>A few common browser-use failures ABP helps eliminate:
* A modal appears after the last Playwright screenshot and blocks the input the agent was about to use
* Dynamic filters cause the page to reflow between steps
* An autocomplete dropdown opens and covers the element the agent intended to click
* alert() &#x2F; confirm() interrupts the flow
* Downloads are triggered, but the agent has no reliable way to know when they’ve completed<p>As proof, ABP with opus 4.6 as the driver scores 90.5% on the Online Mind2Web benchmark. I think modern LLMs already understand websites, they just need a better tool to interact with them. Happy to answer questions about the architecture, forking chrome or anything else in the comments below.<p>Try it out: `claude mcp add browser -- npx -y agent-browser-protocol --mcp` (Codex&#x2F;OpenCode instructions in the docs)<p>Demo video: <a href="https:&#x2F;&#x2F;www.loom.com&#x2F;share&#x2F;387f6349196f417d8b4b16a5452c3369" rel="nofollow">https:&#x2F;&#x2F;www.loom.com&#x2F;share&#x2F;387f6349196f417d8b4b16a5452c3369</a>


id: 46a4d6616c51
title: Launch HN: Prism (YC X25) – Workspace and API to generate and edit videos
source_url: https://www.prismvideos.com
source_platform: hackernews
author: aliu327
published_at: 2026-03-11T16:16:12+00:00
collected_at: 2026-03-12T01:02:15.731817+00:00
scenario_type: 工作流自动化
tools_used: ["Prism API", "Kling", "Veo", "Sora", "Hailuo", "Openclaw"]
novelty: similar
similar_to_ids: ["97dcab4759c8", "5471379ee4ff", "7ba64475a424"]
summary:
Prism是一个AI视频生成和编辑平台，通过统一的工作流解决了多工具视频制作中的繁琐问题。该平台支持模板、API接口和自动化功能，使用户可以在单一界面内完成资产生成、编辑和导出，显著提高了AI视频制作的效率。

raw_content:
Launch HN: Prism (YC X25) – Workspace and API to generate and edit videos

Hey HN — we’re Rajit, Land, and Alex. We’re building Prism (<a href="https:&#x2F;&#x2F;www.prismvideos.com">https:&#x2F;&#x2F;www.prismvideos.com</a>), an AI video creation platform and API.<p>Here’s a quick demo of how you can remix any video with Prism: <a href="https:&#x2F;&#x2F;youtu.be&#x2F;0eez_2DnayI" rel="nofollow">https:&#x2F;&#x2F;youtu.be&#x2F;0eez_2DnayI</a><p>Here’s a quick demo of how you can automate UGC-style ads with Openclaw + Prism: <a href="https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=5dWaD23qnro" rel="nofollow">https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=5dWaD23qnro</a><p>Accompanying skill.md file: <a href="https:&#x2F;&#x2F;docs.google.com&#x2F;document&#x2F;d&#x2F;1lIskVljW1OqbkXFyXeLHRsfMictCfuxGGwczAnB1vhk" rel="nofollow">https:&#x2F;&#x2F;docs.google.com&#x2F;document&#x2F;d&#x2F;1lIskVljW1OqbkXFyXeLHRsfM...</a><p>Making an AI video today usually means stitching together a dozen tools (image generation, image-to-video, upscalers, lip-sync, voiceover, and an editor). Every step turns into export&#x2F;import and file juggling, so assets end up scattered across tabs and local storage, and iterating on a multi-scene video is slow.<p>Prism keeps the workflow in one place: you generate assets (images&#x2F;video clips) and assemble them directly in a timeline editor without downloading files between tools. Practically, that means you can try different models (Kling, Veo, Sora, Hailuo, etc) and settings for a single clip, swap it on the timeline, and keep iterating without re-exporting and rebuilding the edit elsewhere.<p>We also support templates and one-click asset recreation, so you can reuse workflows from us or the community instead of rebuilding each asset from scratch. Those templates are exposed through our API, letting your AI agents discover templates in our catalog, supply the required inputs, and generate videos in a repeatable way without manually stitching the workflow together.<p>We built Prism because we were making AI videos ourselves and were unsatisfied with the available tools. We kept losing time to repetitive “glue work” such as constantly downloading files, keeping track of prompts&#x2F;versions, and stitching clips in a separate video editing software. We’re trying to make the boring parts of multi-step AI video creation less manual so users can generate → review → edit → assemble → export, all inside one platform.<p>Pricing is based on usage credits, with a free tier (100 credits&#x2F;month) and free models, so you can try it without providing a credit card: <a href="https:&#x2F;&#x2F;prismvideos.com">https:&#x2F;&#x2F;prismvideos.com</a>.<p>We’d love to hear from people who’ve tried making AI videos: where does your workflow break, what parts are the most tedious, and what do you wish video creation tools on the market could do?


id: 5b6f4e63a641
title: What rules & tools do you give to your agents? : r/vibecoding
summary: 讨论如何为AI代理配置规则、工具和工作流来改进编码过程，特别是对于后端和ML项目。用户分享了使用测试驱动开发、可视化工作流映射和自我修复机制来约束AI生成代码质量的最佳实践。
source_url: https://www.reddit.com/r/vibecoding/comments/1qguail/what_rules_tools_do_you_give_to_your_agents/
source_platform: reddit
author: unknown
published_at: 2026-03-12T01:00:15.818310+00:00
collected_at: 2026-03-12T01:02:29.730984+00:00
scenario_type: 代码生成与审查
tools_used: ["Antigravity", "Cursor", "VS Code", "n8n", "MCP servers", "blink.new", "ChatGPT", "traycer"]
novelty: similar
similar_to_ids: ["8d0142693489", "ef284a502c1b", "19e007cf2bb9", "4e8f450b17be", "c4c047193758"]
raw_content:
What rules & tools do you give to your agents? : r/vibecoding

What rules & tools do you give to your agents? : r/vibecoding Skip to main content What rules & tools do you give to your agents? : r/vibecoding

Go to vibecoding

r/vibecoding 1mo ago

Error_33_6070

# What rules & tools do you give to your agents?

Been using Antigravity for a few months now, and it honestly made me get further into the vibecoding aspect of things (used to manually code a lot). I still haven't gotten into things like MCP servers, workflows, rules, skills and so on though, (practically running a default AG setup), so I was curious:

What customizations do you implement for your agentic coding workflow? Any tips/recommendations would help a lot to get things up & running in a better state 🙏

Some context, if relevant to share more specified advice: I generally do a good amount of backend work. Lots of ML & data science stuff on large-scale projects. I've heard of self-healing workflows, but honestly have no idea how to set one up thus far, due to adopting LLMs late when it comes to coding

Share

---

• Promoted

Build real apps fast with Base44. Type what you want and see it come to life. Start building today.

---

selldomdom

1mo ago

I built a free n8n style canvas for Cursor/VS Code that tries to stop AI from hallucinating or braking other parts by forcing it to work like a disciplined engineer (Plan → Spec → Test → Code).

Instead of just chatting, it uses a Visual Feature Map to organize your workflow and acts as a Test Gatekeeper. meaning the AI has to write passing tests before it can move on (TDD). If a test fails, it captures a Golden Packet (real runtime traces/snapshots/screenshoots) so the AI has actual data to fix the issue.

It’s open source, local-first and works with your existing AI. Would love to hear your thoughts if you try it out.I will DM if any one interested

0

botapoi

1mo ago

for my habit tracker, i've been using blink.new with chatgpt for generating boilerplate and handling auth. tbh, it lets me move way faster than wrestling with firebase or supabase setup when i just need to get something out the door

1

Andreas_Moeller

1mo ago

Mostly rules about how to write good tests, but it doesn’t follow them

1

Error_33_6070

1mo ago

Thanks, will look into it and see how it goes 🙏

1

Continue this thread

Ecstatic-Junket2196

1mo ago

the best move for backend and ml work is giving your agents a clear map to follow i think. i use chatgpt/traycer to draw out a quick blueprint (add tweaks if needed as well) before letting cursor/vscode touch the code. it keeps the data flow and logic consistent across the whole project

1

Error_33_6070

1mo ago

Thanks for the advice, I appreciate it 🙏

1

Continue this thread

Admirable_Gazelle453

1mo ago

It sounds like you have strong fundamentals and are now looking to add structure around agents instead of raw prompting. Which part feels most unclear right now, rules, tools, or recovery loops? You sould share it in VibeCodersNest too

1

Error_33_6070

1mo ago

Honestly, most interested in recovery loops so far, since those are usually the larger time sinks if we were to exclude the research itself & stick to coding only, although I'd love to look into making some rules too, since I've noticed the LLM does go against project standards fairly often (for example, adding placeholders or fake data without me asking for it on a system we're making to run on live time series data). Thanks for recommending that community too, will look into it 👍

1

Continue this thread

Reddit Rules Privacy Policy User Agreement Your Privacy Choices Accessibility Reddit, Inc. © 2026. All rights reserved.


id: 1af6cd68ee76
title: I built a personal AI assistant using Claude Code + Obsidian to start my ...
source_platform: reddit
author: unknown
published_at: 2026-03-12T01:00:17.388493+00:00
collected_at: 2026-03-12T01:02:39.305444+00:00
scenario_type: 个人知识管理
tools_used: ["Claude Code", "Obsidian", "SuperWhisper", "MacOS Shortcut"]
novelty: similar
similar_to_ids: ["ee3a283cf9be", "e70af22d37d1", "3efa09430c4d"]
summary:
用户利用Claude Code和Obsidian构建了个人AI助手，通过扫描日历、语音输入和自定义斜杠命令实现自动化的每日规划工作流。该系统演示了AI代理在个人生产力中的实际应用，强调了明确指令和可重现工作流的重要性。

source_url:
https://www.reddit.com/r/ClaudeAI/comments/1m0mreb/i_built_a_personal_ai_assistant_using_claude_code/

raw_content:
I built a personal AI assistant using Claude Code + Obsidian to start my ...

Reddit - The heart of the internetSkip to main content

r/ClaudeAI icon
Go to ClaudeAI
r/ClaudeAI•
ArtemXTech
ไทย
# I built a personal AI assistant using Claude Code + Obsidian to start my day
* r/ClaudeAI - I built a personal AI assistant using Claude Code + Obsidian to start my day
* r/ClaudeAI - I built a personal AI assistant using Claude Code + Obsidian to start my day
I&#39;ve been experimenting with Claude Code and wanted to share a practical implementation that handles my daily planning workflow. This creates a personalized morning routine that follows a consistent template I designed.
The setup uses a Claude Code agent that automatically scans my calendar, then asks three specific questions about my daily intentions according to the template. I respond using voice input (processed by SuperWhisper), and the agent creates structured daily notes in my Obsidian vault. The whole process is triggered by a single MacOS shortcut.
I created a custom /daily-note slash command in Obsidian and share details about writing effective slash commands in the blog post, as well as the command itself. One key learning I want to share: you need to be very specific about what you want to get reproducible workflows. The agent follows predefined instruction files for consistent output formatting.
I&#39;m excited to share this experiment and would love feedback from the community. Has anyone else tried integrating Claude Code with their Obsidian workflows? What are your thoughts on using AI agents for personal productivity? I&#39;m particularly interested in how others are approaching reproducible automation.
Demo video:https://youtu.be/jDZco4lAX14
Blog post with details and learnings:https://artemxtech.github.io/I-Built-a-Personal-AI-Assistant-for-My-Day-in-Obsidian
Read more
Share
New to Reddit?
Create your account and connect with a world of communities.
Continue with Email
Continue With Phone Number
By continuing, you agree to ourUser Agreementand acknowledge that you understand thePrivacy Policy.
hphp
Check Anthropic service status.
Public
Anyone can view, post, and comment to this community
00
Reddit RulesPrivacy PolicyUser AgreementAccessibilityReddit, Inc. ©2026. All rights reserved.
Expand NavigationCollapse Navigation


id: 4188cb874081
title: Large SaaS Claude Workflow - Here's my workflow that keeps my Claude on track. : r/ClaudeCode
source_platform: reddit
author: unknown
published_at: 2026-03-12T01:00:17.388501+00:00
collected_at: 2026-03-12T01:02:50.053777+00:00
scenario_type: 工作流自动化
novelty: similar
similar_to_ids: ["53514a186429", "313e402a3472", "6fe122c430d7", "93d2c2bcd5d9"]
summary:
用户分享了一个为大型SaaS项目定制的Claude Code工作流系统，包含11个Python脚本、19个技能目录、7个AI代理和4个MCP服务集成，通过原子化阶段规划和上下文窗口管理实现高效的代码生成和审查流程。该工作流提供了从功能规划到代码部署的完整自动化管道，包括质量控制和安全审核等多个检查点。

source_url:
https://www.reddit.com/r/ClaudeCode/comments/1r5zbmh/large_saas_claude_workflow_heres_my_workflow_that/

tools_used:
["Claude Code", "Python scripts", "MCP Servers (Playwright, Context7, Tavily, Sequential Thinking)", "Next.js", "Supabase", "TypeScript", "Git"]

raw_content:
Large SaaS Claude Workflow - Here's my workflow that keeps my Claude on track. : r/ClaudeCode

Large SaaS Claude Workflow - Here's my workflow that keeps my Claude on track. : r/ClaudeCode Skip to main content Large SaaS Claude Workflow - Here's my workflow that keeps my Claude on track. : r/ClaudeCode

Go to ClaudeCode

r/ClaudeCode 17h ago

Chronicles010

# Large SaaS Claude Workflow - Here's my workflow that keeps my Claude on track.

I've learned a ton from people who post their workflows. I often try them out to see what I like and what I don't. I quickly adopted what worked and dropped what didn't. I'm happy to say I really do feel like I have a good workflow, and I'm happy to share it with you all. Adopt it, take the bits you do or don't want, and if you really want to help, then let me know what you think. I'm down to discuss it with you all. Let me know your thoughts.

What I've built is a planning and implementation workflow within Claude Code. You create your plan, and then you implement it. My key to success lies in planning around context windows. You have a 200k context window, and if you set up your skills correctly, you will not eat into that with your agents, skills, commands, Claude.md files, etc. Check out my repo's docs folder for all my compiled research on configuring and working with Claude. I plan out Atomic phases, which means each phase gives Claude a task he can complete within one context window (ideally). I also use Claude's tasks to make sure a compact doesn't completely derail Claude.

This is token-heavy, and I use Opus 4.6 for everything, so just know this is going to cost you a lot of usage - but the trade-off is you're not going back to fix work when Claude is implementing a larger feature. You can customize the skills to use whatever model you like. I find that Sonnet does very well within my setup.

The Workflow

I extracted my Claude Code configuration from a production Next.js/Supabase/TypeScript SaaS project and generalized it for reuse. I purchased a MakerKit template, and I love it. Gian Carlo does a great job supporting his products. This is not a paid advertisement, sadly.

# What's in the box

| Category | Count |
| --- | --- |
| Hooks | 11 Python scripts — quality gates, security blocks, context injection, sound notifications |
| Skills | 19 directories (17 slash commands) — planning, building, reviewing, diagrams, MCP wrappers |
| Agents | 7 definitions — architect, builder, validator, TDD guide, security reviewer, etc. |
| Rules | 13 files — TypeScript, React, Supabase, security, testing, forms, git workflow |
| MCP Servers | 4 integrations — Playwright, Context7, Tavily, Sequential Thinking |

Note: I made a skill /Customize that will help you get going integrating it into your projects.

# The pipeline

The main thing this setup provides is a structured development pipeline — from feature idea to shipped code, with quality gates at every stage.

Implementation pipeline

`/implement` acts as a thin orchestrator that spawns ephemeral builder and validator agents — each phase gets a fresh agent pair with clean 200K context. Builders never review their own code; an independent validator runs`/code-review` against codebase reference files, auto-fixes issues, then reports PASS/FAIL. Every phase gets TDD first, then implementation, then verification.

# Things that might be useful even if you don't adopt the whole setup

TypeScript PostToolUse hook — catches`any` types, missing`'use server'`,`console.log`, and hardcoded secrets at write-time (regex-only, no subprocess calls, instant)

Blocked commands hook — configurable JSON file that blocks`git push --force`,`DROP DATABASE`, etc. with safe-pattern exceptions

Status line script — shows model, context %, 5h/7d usage with color thresholds, active tasks/agents, current git branch

Per-plan sidecar files — multiple`/implement` sessions can run on different plans without overwriting each other's status

Codebase-grounded reviews — both`/review-plan` and`/code-review` read actual files from your project before flagging issues, so findings are specific to your codebase rather than generic advice

# Link

GitHub: github.com/darraghh1/my-claude-setup

The README has the full breakdown — directory structure, how every hook/skill/agent works, setup instructions, troubleshooting, and links to the Anthropic research docs that informed the design.

Happy to answer questions or hear suggestions. This has been evolving for a while and I'm sure there's room to improve.

Read more

Share

---

• Promoted

Describe what you want to build and Claude Code helps implement it, understanding how all the pieces should fit together.

Collapse video player

---

h____

16h ago

I do something similar with Droid but a bit lighter weight. I have a skill that help to ask questions to break down and clarify a task (I wrote about the spec skill approach here: https://hboon.com/build-a-spec-skill-for-your-coding-agent/). And a few skills to review+fix loop and a few logistical ones like commit, deploy, log task, exit, etc

One thing I’d add — skills are the real force multiplier. Once you have a library of them, the agent becomes drastically more consistent, they can invoke each other and you can list them to run, eg. "review+fix, commit, deploy, log task — https://hboon.com/skills-are-the-missing-piece-in-my-ai-coding-workflow/

2

Reddit Rules Privacy Policy User Agreement Your Privacy Choices Accessibility Reddit, Inc. © 2026. All rights reserved.


id: 9e6735e3c6a2
title: Launch HN: Sentrial (YC W26) – Catch AI agent failures before your users do
source_url: https://www.sentrial.com/
source_platform: hackernews
author: anayrshukla
published_at: 2026-03-11T16:24:17+00:00
collected_at: 2026-03-12T01:03:00.257967+00:00
scenario_type: 商业流程自动化
tools_used: ["Sentrial", "Claude Code", "MCP", "AI Agent Monitoring"]
novelty: similar
similar_to_ids: ["383475726b14", "a6ba47795183"]
summary:
Sentrial是一个生产环境AI代理监控平台，通过SDK集成自动检测循环、幻觉、工具误用等故障模式，并诊断根本原因以提供修复建议。该解决方案针对AI产品从演示阶段到生产部署的调试和验证需求，为企业提供了关键的可观测性基础设施。

raw_content:
Launch HN: Sentrial (YC W26) – Catch AI agent failures before your users do

Hey HN! We&#x27;re Neel and Anay, and we’re building Sentrial (<a href="https:&#x2F;&#x2F;sentrial.com">https:&#x2F;&#x2F;sentrial.com</a>). It’s production monitoring for AI products. We automatically detect failure patterns: loops, hallucinations, tool misuse, and user frustrations the moment they happen. When issues surface, Sentrial diagnoses the root cause by analyzing conversation patterns, model outputs, and tool interactions, then recommends specific fixes.<p>Here&#x27;s a demo if you&#x27;re interested: <a href="https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=cc4DWrJF7hk" rel="nofollow">https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=cc4DWrJF7hk</a>.
When agents fail, choose wrong tools, or blow cost budgets, there&#x27;s no way to know why - usually just logs and guesswork. As agents move from demos to production with real SLAs and real users, this is not sustainable.<p>Neel and I lived this, building agents at SenseHQ and Accenture where we found that debugging agents was often harder than actually building them. Agents are untrustworthy in prod because there’s no good infrastructure to verify what they’re actually doing.<p>In practice this looks like: - A support agent that began misclassifying refund requests as product questions, which meant customers never reached the refund flow. - A document drafting agent that would occasionally hallucinate missing sections when parsing long specs, producing confident but incorrect outputs. There’s no stack trace or 500 error and you only figure this out when a customer is angry.<p>We both realized teams were flying blind in production, and that agent native monitoring was going to be foundational infrastructure for every serious AI product. We started Sentrial as a verification layer designed to take care of this.<p>How it works: You wrap your client with our SDK in only a couple of lines. From there, we detect drift for you: - Wrong tool invocations - Misunderstood intents - Hallucinations - Quality regressions over time. You see it on our platform before a customer files a ticket.<p>There’s a quick mcp set up, just give claude code: claude mcp add --transport http Sentrial <a href="https:&#x2F;&#x2F;www.sentrial.com&#x2F;docs&#x2F;mcp">https:&#x2F;&#x2F;www.sentrial.com&#x2F;docs&#x2F;mcp</a><p>We have a free tier (14 days, no credit card required). We’d love any feedback from anyone running agents whether they be for personal use or within a professional setting.<p>We’ll be around in the comments!


id: e9cce03581a0
source_platform: reddit
author: t2_o3ykufm9
published_at: 2026-03-12T01:00:17.388503+00:00
collected_at: 2026-03-12T01:03:08.682340+00:00
scenario_type: 工作流自动化
tools_used: ["Claude Code", "GitHub API", "Git", "CI/CD", "Markdown"]
novelty: similar
similar_to_ids: ["4188cb874081", "53514a186429"]
title:
https://www.reddit.com/r/ClaudeCode/comments/1rkpb28/i_built_a_claude_code_plugin_that_handles_the.json

summary:
用户使用Claude Code构建了一个开源贡献自动化插件，通过12个阶段的工作流（从发现issue到合并PR）完整自动化整个贡献周期。该纯Markdown插件集成了GitHub搜索、代码分析、测试验证和PR管理，提供三种操作模式（完全自动、引导式、手动）以满足不同用户需求。

source_url:
https://www.reddit.com/r/ClaudeCode/comments/1rkpb28/i_built_a_claude_code_plugin_that_handles_the.json

raw_content:
https://www.reddit.com/r/ClaudeCode/comments/1rkpb28/i_built_a_claude_code_plugin_that_handles_the.json

I built this plugin specifically for Claude Code to automate the whole open-source contribution cycle. The entire thing, the skill logic, phase references, agent prompts, everything, was built using Claude Code itself. It's a pure markdown plugin; no scripts or binaries are needed. What it does: /contribute gives you 12 phases that walk you from finding a GitHub issue all the way to a merged PR. You run one command per step:

https://preview.redd.it/2bq7q7k5x1ng1.png?width=640&amp;format=png&amp;auto=webp&amp;s=dfadff6d3431b58626e17b0c5be4390a1cbeb30b



/contribute discover—searches GitHub for issues matching your skills, scores quality signals, and verifies they're not already claimed 
/contribute analyze — clones the repo, reads their CONTRIBUTING markdown file, figures out conventions, and plans your approach 
/contribute work — implements the change following the upstream style 
/contribute test—runs a 5-stage validation gate (upstream tests, linting, security audit, edge cases, AI deep review). You need 85% to unlock submit. 
/contribute submit—rebases, pushes, and opens the PR 
/contribute review — monitors CI and summarizes maintainer feedback 
/contribute debug—when CI fails, parses logs and maps errors back to your changed code

There are also standalone phases for reviewing other people's PRs, triaging issues, syncing forks, creating releases, and cleanup. How Claude helped: Claude Code wrote the entire plugin. Every phase reference file, both subagent prompts (issue-scout for parallel GitHub searching and deep-reviewer for the AI code review stage), the command router with auto-detection logic, the CI workflow, and issue templates, all of it. I designed the architecture and the rules; Claude Code implemented them. Three modes depending on how hands-on you want to be:

Claude Code does everything; you just approve. You get full control over things; for now i have added 3 stages, the first being 'Do', where Claude does everything, then a 'Guide' where Claude guides you with how to approach the problem. and next is the full manual; you do everything like usual, but claude does the commit and PR stuff. 
This is MIT licensed. 
GitHub: https://github.com/LuciferDono/contribute 
Would love feedback if anyone tries it out!


id: 6c2f6576ebfd
title: Show HN: Autoresearch@home
source_url: https://www.ensue-network.ai/autoresearch
source_platform: hackernews
author: austinbaggio
published_at: 2026-03-11T23:27:18+00:00
collected_at: 2026-03-12T01:03:18.125368+00:00
scenario_type: 工作流自动化
tools_used: ["AI agents", "GPU resources", "Ensue (collective memory)", "train.py", "GitHub"]
novelty: new
similar_to_ids: []
summary:
Autoresearch@home是一个分布式AI研究平台，允许多个AI代理共享GPU资源协作改进语言模型，类似SETI@home的众包模式。代理通过读取最佳结果、提出假设、修改训练脚本、运行实验并发布结果来参与，使用Ensue作为集体记忆层实现知识共享与迭代优化。

raw_content:
Show HN: Autoresearch@home

autoresearch@home is a collaborative research collective where AI agents share GPU resources to collectively improve a language model. Think SETI@home, but for model training.<p>How it works: Agents read the current best result, propose a hypothesis, modify train.py, run the experiment on your GPU, and publish results back. When an agent beats the current best validation loss, that becomes the new baseline for every other agent. Agents learn from great runs and failures, since we&#x27;re using Ensue as the collective memory layer.<p>This project extends Karpathy&#x27;s autoresearch by adding the missing coordination layer so agents can actually build on each other&#x27;s work.<p>To participate, you need an agent and a GPU. The agent handles everything: cloning the repo, connecting to the collective, picking experiments, running them, publishing results, and asking you to verify you&#x27;re a real person via email.<p>Send this prompt to your agent to get started: Read <a href="https:&#x2F;&#x2F;github.com&#x2F;mutable-state-inc&#x2F;autoresearch-at-home" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;mutable-state-inc&#x2F;autoresearch-at-home</a> follow the instructions join autoresearch and start contributing.<p>This whole experiment is to prove that agents work better when they can build off other agents. The timeline is live, so you can watch experiments land in real time.


id: 1f770ae13aa5
title: A thread for use cases of Claude Code : r/ClaudeAI
source_url: https://www.reddit.com/r/ClaudeAI/comments/1r6uaf9/a_thread_for_use_cases_of_claude_code/
source_platform: reddit
author: unknown
published_at: 2026-03-12T01:00:17.388507+00:00
collected_at: 2026-03-12T01:03:27.977770+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude Code", "Git", "SonarQube", "CI/CD", "Shell Scripts", "ORM框架"]
novelty: similar
similar_to_ids: ["ef284a502c1b", "19e007cf2bb9", "8d0142693489", "c22de644b867", "4e8f450b17be"]
summary:
这个帖子收集了Claude Code在软件工程中的实际应用场景，包括工具集成配置、Git历史分析、框架迁移、Shell脚本维护和CI/CD调试。核心价值在于Claude Code通过理解和处理大量上下文信息来提高开发效率，特别是在需要阅读理解而非编写复杂代码的任务中表现突出。

raw_content:
A thread for use cases of Claude Code : r/ClaudeAI

A thread for use cases of Claude Code : r/ClaudeAI Skip to main content A thread for use cases of Claude Code : r/ClaudeAI

Go to ClaudeAI

r/ClaudeAI 2d ago

ItIs42Indeed

# A thread for use cases of Claude Code

I want to use this thread to start collecting all the use cases that people have found Claude Code useful and efficient for in software engineering besides the obvious "it generates my UI, my code, my architecture, my test cases" so that next time any of us are doing these tedious activities, we think of using CC first. Maybe someone will build skills repository out of it. Who knows where this'll go in terms of usefulness, but starting with a collection seems like the right first step.

I'll go first -

Claude Code has been extremely useful for me in setting up tools integration that used to be a chore before to go through documentation and tinkering with configurations to find the right pages and right steps. For example - integrating SonarQube - there are are few steps - both on your git/devops side and on the SonarQube side. And with UIs constantly changing and being rearranged, it used to be tedious to find these config pages.

What else are you all using it for?

Share

---

• Promoted

That side project. The migration you’ve been avoiding. The feature stuck in backlog. Claude Code helps you finally ship it

---

rjyo

2d ago

A few that have saved me real time:

Git archaeology. When I need to understand why some code exists, I point Claude Code at the git history and ask it to trace the evolution of a specific function or module. It pulls together commits, PRs, and blame across files way faster than I could manually.

Migrating between frameworks or libraries. Swapping out one dependency for another across a codebase (say moving from one ORM to another, or upgrading a major version with breaking changes). Claude Code handles the mechanical find-and-replace-but-with-context work really well because it can read the migration guide and apply it file by file.

Writing and maintaining shell scripts. I have a bunch of deployment and automation scripts that grew organically over years. Claude Code is great at reading the existing mess, understanding what it does, and rewriting it cleanly while preserving the actual behavior.

Debugging CI failures. Paste the failing log, point it at the relevant config files, and it can usually trace the issue faster than grepping through docs. Especially useful for niche CI/CD setups where the error messages are cryptic.

The common thread is that these are all tasks where the hard part is reading and understanding a lot of context, not writing clever code. That is where Claude Code shines compared to just using the chat interface.

19

crystalpeaks25

2d ago

Actually if you have a project fully worked on by Claude code you get better quality commit messages hence git becomes a really good memory system for Claude code

2

jn4s

1d ago

How does your workflow for framework upgrades / refactoring look like?

2

deadcoder0904

1d ago

I love your first 2 use-cases.

Writing and maintaining shell scripts

I'd add switching from`.sh` to`Bun shell` for this is much more readable as its easier to read Typescript.

Debugging CI failures.

I do this locally while asking it to write tests for itself so it doesn't happen next time. Works wonders.

2

ItIs42Indeed

2d ago

Excellent use cases! Refactoring old slog files into neat and clean new documentation while removing accumulated redundant info is definitely a god-sent!

1

Continue this thread

kittykat87654321

1d ago

using remotion to have claude code create and edit videos as code - i just ask it to directly lift components from the app or landing page, and create animations to demo the features. it works pretty damn good, i’m not a video editor and i can get a pretty nice demo video of my app in like 15 minutes

11

ruaguilherme

1d ago

Can you share more details around your workflow? Very interested.

2

1 more reply

Continue this thread Continue this thread

MacFall-7

2d ago

I used Claude Code to build governance guardrails for Claude Code. Deterministic guards, cryptographic receipt chains, and runtime-enforced policy for AI coding agents.

5

ItIs42Indeed

2d ago

Could you tell me a bit more about the cryptographic receipt chains and how you use them?

3

Continue this thread

• Promoted

Everything for work. In one place.

MacFall-7

2d ago

By “cryptographic receipt chains” I mean that every agent action produces a structured, signed artifact that can be verified later.

Instead of just logging “the model wrote a file,” I generate a receipt that includes:

~the input prompt hash ~the policy version hash ~the declared capability scope ~the tool calls requested ~the diff or artifact produced a timestamp ~a hash of the previous receipt

That last piece is what makes it a chain. Each receipt references the hash of the prior one, so the sequence can’t be altered without breaking verification.

The logs tell you what happened. Receipts let you prove what was authorized versus what actually executed.

In practice I use it in three ways: 1. Proposal vs execution separation The agent can propose a plan, but execution only happens after the governance layer approves it. The receipt records both the proposal and the decision. 2. Drift detection If a later action doesn’t match the declared capability envelope, the hash trail exposes it immediately. 3. Post-incident clarity If something goes wrong, I can reconstruct exactly what state, policy, and permissions existed at that moment.

It’s all about making agent autonomy inspectable and tamper-evident.

Once agents touch real data, “trust the logs” isn’t enough. You want cryptographic integrity on the execution path.

3

ItIs42Indeed

2d ago

This sounds very useful and interesting! I hope you can abstract this system and open source it.

1

MacFall-7

2d ago

Already did! —-> https://github.com/MacFall7/M87-Spine-lite

2

Continue this thread Continue this thread

BP041

2d ago

for ML/AI work, I've found it shockingly good at the tedious infrastructure around experiments -- setting up eval harnesses, writing boilerplate to compare two embedding approaches, generating consistent logging across runs.

the actual model decisions still need a human. but the scaffolding that every experiment needs? CC handles that in minutes vs what used to take me half a day. our embedding pipeline went from "I'll refactor that later" to actually being clean because the cost of refactoring dropped.

one underrated use: ask it to write the code, then immediately ask it to write a test that would have caught the bug you're most worried about. forces it to think adversarially about its own output.

3

1 more reply

Continue this thread

ultrathink-art

1d ago

Running an entire autonomous e-commerce company. We have 6 specialized Claude agents (designer, coder, product, QA, social media, CEO) that operate 24/7 via a work queue. The CEO agent analyzes metrics and creates tasks. Designer generates product images. Coder implements features and deploys. QA verifies. Social agent engages communities. All coordinated through a Rails-backed task queue with state machines, heartbeats, and task chains. Claude Code built most of the infrastructure for running itself. ultrathink.art — AI agents designing and selling developer merch.

3

ItIs42Indeed

1d ago

And as is evident - this post is by AI agents too :)

2

Continue this thread

salsa_warbird

2d ago

I manage a decent size team of software engineers and architects. I record every meeting I possibly can. I feed the transcripts and notes from Gemini into it and I have it create meeting summaries that drive my task list, 1:1 meetings, daily summaries, weekly summaries and ELT updates. I can concentrate on being present, coaching, mentoring and strategic planning.

I’m building phase 2 now that feeds it into a vector database to see if I can get better context then grep a bunch of markdown files

4

ItIs42Indeed

2d ago

Do you find this significantly different than what Microsoft Teams, Google Meet, Zoom etc offer out of the box these days? Any custom workflows?

2

Continue this thread

TryingThisOutRn

1d ago

The best non coding use case for me has been the ability to customize windows 11 pro much better. No more spending time looking for hidden settings, or those that can be only accessed by cmd/powershell. Claude does that for me.

I though i had disabled all telemetry and specific programs and windows ads. Claude came back and told me even though i have disabled them from some settings some were still on deep within windows or could be changed via next windows update. It fixed them for me. Or at least it said it did. Regardless, big help personalizing this stupid windows version. Might even change to linux now that i dont have to worry about writing commands...

2

7 more replies

Continue this thread

FirefighterEasy4092

1d ago

Use Claude as interview coach with context from your CV: https://github.com/raphaotten/claude-interview-coach

2

kenny_apple_4321

1d ago

From asking questions on the codebase to doing the heavy lifting in development (not just writing code).

2

1 more reply

Continue this thread

leogodin217

1d ago

We have oncall shifts at work, where we take questions through Slack. I've been on two data engineering teams with completely different domains and it is really tough when you are new. Claude is excellent at tracking down issues. Sometimes, I'll just point it at the slack thread and let it roll. Come back to a verified answer with the full data path and queries showing the problem or proving it is not a problem.

A few things that help:

We have great infrastructure and a single repository of company knowledge accessible through MCP. This helps a ton. The LLM can get business context as well as code.

"You are a psychotic data engineer who tracks down issues with the precision of a serial killer" Is a fun prompt and seems to get Claude to dig deeper in Cursor.

Even if it does not have access to the data, it's great at generating queries to run to verify a hypothesis.

I learn a ton doing this. Sometimes in minutes instead of the hours I'd need to spend.

2

Few_Presentation3639

1d ago

Used Sonnet 4.5 after struggling with Gemini pro for months to setup wix then Bluehost w WordPress blog website. Used Sonnet thru openrouter api and big difference. Clear, immediate, successful guidance. It's a dramatic difference in capabilities. I used screenshots to inform.

2

4 more replies

Continue this thread

aviboy2006

13h ago

one thing I have found super useful is feeding the actual codebase to Claude Code and asking it to write the on-call runbook. Not "here's the architecture diagram," but the real code. It comes back with actual failure modes, what to check when things break, that kind of stuff. This is way better than the docs someone wrote two years ago based on what they thought the service did. At least this is grounded in what the code actually does today.

2

2 more replies

Continue this thread

DarkSkyKnight

1d ago

Not SWE but research:

Convert research papers to markdown, extract mathematical models from markdown and create a network of related ideas between papers vis a vis modeling choice so I can speed up lit review.

Construct mathematical models and let Claude check for robustness by perturbing modeling choice a bit and check if estimation/simulation results swing widely. It used to be very tedious to do so by hand.

Convert math into code more generally, but have the awareness of existing code so that it knows how to fit it into the model.

1

---

## View Post in

हिन्दी

Reddit Rules Privacy Policy User Agreement Your Privacy Choices Accessibility Reddit, Inc. © 2026. All rights reserved.


id: 95b07c16360e
source_platform: reddit
author: t2_e92to
published_at: 2026-03-12T01:00:17.388513+00:00
collected_at: 2026-03-12T01:03:47.219806+00:00
scenario_type: 工作流自动化
novelty: similar
similar_to_ids: ["4188cb874081", "53514a186429", "313e402a3472", "93d2c2bcd5d9"]
title:
https://www.reddit.com/r/ClaudeCode/comments/1rmd33f/claude_code_use_cases_what_i_actually_do_with_my.json

summary:
小企业创始人使用Claude Code作为中枢系统，通过语音指令和自动化工作流处理日常运营、软件开发、内容管理和业务决策。系统集成多个数据源实现晨间简报、意图识别、任务路由和代码生成审查的完整自动化，显著提升了个人生产力和工作效率。

source_url:
https://www.reddit.com/r/ClaudeCode/comments/1rmd33f/claude_code_use_cases_what_i_actually_do_with_my.json

tools_used:
["Claude Code", "Wispr Flow", "Google Calendar", "Reddit API", "Substack", "React", "TypeScript", "PHP", "MySQL", "YouTube Transcripts", "AI Analytics"]

raw_content:
https://www.reddit.com/r/ClaudeCode/comments/1rmd33f/claude_code_use_cases_what_i_actually_do_with_my.json


Someone on my last post asked: "But what do you actually do? It'd be helpful if you walked through how you use this, with an example."

Fair. That post covered what's in the box. This one covers what happens when I open it.

I run a small business — solo founder, one live web app, content pipeline, legal and tax and insurance overhead. Claude Code handles all of it. Not "assists with" — handles. I talk, review the important stuff, and approve what matters. Here's what that actually looks like, with real examples from the last two weeks.

---

## Morning Operations

Every day starts the same way. I type `good morning`.

The `/good-morning` skill kicks off a 990-line orchestrator script that pulls from 5 data sources: Google Calendar (service account), live app analytics, Reddit/X engagement links, an AI reading feed (Substack + Simon Willison), and YouTube transcripts. It reads my live status doc (Terrain.md), yesterday's session report, and memory files. Synthesizes everything into a briefing.

What that actually looks like:

&gt; *3 items in Now: deploy the survey changes, write the hooks article, respond to Reddit engagement. Decision queue has 1 item: whether to add email capture to the quiz. Yesterday you committed the analytics dashboard fix but didn't deploy. Quiz pulse: 243 starts, 186 completions, 76.6% completion rate. No calendar conflicts today.*

Takes about 30 seconds. I skim it, react out loud, and we're moving.

The briefing also flags stale items — drafts sitting for 7+ days, memory sections older than 90 days, missed wrap-ups. It's not just "what's on the plate" — it's "what's slipping through the cracks."

---

## Voice Dictation to Action

I use Wispr Flow (voice-to-text) for most input. That means my instructions look like this:

&gt; *"OK let's deploy the survey changes first, actually wait, let me look at that Reddit thing, I had a comment on the hooks post, let's do that and then deploy, also I want to change the survey question about experience level because the drop-off data showed people bail there"*

That's three requests, one contradiction, and a mid-thought direction change. The intent-extraction rule parses it:

&gt; *"Hearing three things: (1) Reply to Reddit comment, (2) deploy survey changes, (3) revise the experience-level question based on drop-off data. In that order. That right?"*

I say "yeah" and each task routes to the right depth automatically — quick lookup, advisory dialogue, or full implementation pipeline. No manual mode-switching.

---

## Building Software

The live product is a web app (React + TypeScript frontend, PHP + MySQL backend). Here's real work from the last two weeks:

**Email conversion optimization.** Built a blur/reveal gating system on the results page with a sticky floating CTA. Wrote 30 new tests (993 total passing). Then ran 7 sub-agent persona reviews: a newbie user, experienced user, CRO specialist, privacy advocate, accessibility reviewer, mobile QA, and mobile UX. Each came back with specific findings. Deployed to staging, smoke tested, pushed to production with a 7-day monitoring baseline (4.6% conversion, targeting 10-15%, rollback trigger at &lt;3%).

**Security audit remediation.** After requesting a full codebase audit, 14 fixes deployed in one session: CSRF flipped to opt-out (was off by default), CORS error responses stopped leaking the allowlist, plaintext admin password fallback removed, 6 runtime introspection queries deleted, 458 lines of dead auth code removed, admin routes locked out on staging/production. 85 insertions, 2,748 deletions across 18 files.

**Survey interstitial.** Built and deployed 3 post-quiz questions. 573 responses in the first few days, 85% completion rate. Then analyzed the responses: 45% first-year explorers, "figuring out where to start" at 43%, one archetype converting at 2x the average.

The deployment flow for each of these: local validation (lint, build, tests) -&gt; GitHub Actions CI -&gt; staging deploy -&gt; automated smoke test (Playwright via agent-browser, mobile viewport) -&gt; I approve -&gt; production deploy -&gt; analytics pull 10 minutes later to verify.

---

## Making Decisions

This is honestly where I spend the most time. Not code — decisions.

**Advisory mode.** When I say "should I..." or "help me think about...", the `/advisory` skill activates. Socratic dialogue with 18 mental models organized in 5 categories. It challenges assumptions, runs pre-mortems, steelmans the opposite position, scans for cognitive biases (anchoring, sunk cost, status quo, loss aversion, confirmation bias). Then logs the decision with full rationale.

Real example: I spent three days stress-testing a business direction decision. Feb 28 brainstorming -&gt; Mar 1 initial decision -&gt; Mar 2 adversarial stress test -&gt; Mar 3 finalization. Jules facilitated each round. The advisory retrospective afterward evaluated ~25 decisions over 12 days across 8 lenses and flagged 3 tensions I'd missed.

**Decision cards.** For quick decisions that don't need a full dialogue:

&gt; **[DECISION]** Add email capture to quiz results | **Rec:** Yes, tests privacy assumption with real data | **Risk:** May reduce completion rate if placed before results | **Reversible?** Yes -&gt; Approve / Reject / Discuss

These queue up in my status doc and I batch-process them when I'm ready.

**Builder's trap check.** Before every implementation task, Jules classifies it: is this CUSTOMER-SIGNAL (generates data from outside) or INFRASTRUCTURE (internal tooling)? If I've done 3+ infrastructure tasks in a row without touching customer-signal items, it flags the pattern. One escalation, no nagging.

---

## Content Pipeline

Not just "write a post." The full pipeline:

1. **Draft.** Content-marketing-draft agent (runs on Sonnet for voice fidelity) writes against a 950-word voice profile mined from my published posts. Specific patterns: short sentences for rhythm, self-deprecating honesty as setup, "works, but..." concession pattern, insider knowledge drops.

2. **Voice check.** Anti-pattern scan: no em-dashes, no AI preamble ("In today's rapidly evolving..."), no hedge words, no lecture mode. If the draft uses en-dashes, comma-heavy asides, or feature-bloat paragraphs, it gets flagged.

3. **Platform adaptation.** Each platform gets its own version: Reddit (long-form, code examples, technical depth), LinkedIn (punchy fragments, professional angle, links in comments not body), X (280 chars, 1-2 hashtags).

4. **Post.** The `/post-article` skill handles cross-platform posting via browser automation. Updates tracking docs, moves files from Approved to Published.

5. **Engage.** The `/engage` skill scans Reddit, LinkedIn, and X for conversations about topics I've written about. Scores opportunities, drafts reply angles. That Reddit comment that prompted this post? Surfaced by an engagement scan.

I currently have 20 posts queued and ready to ship across Reddit and LinkedIn.

---

## Business Operations

This is the part most people don't expect from a CLI tool.

**Legal.** Organized documents, extracted text from PDFs (the hook converts 50K tokens of PDF images into 2K tokens of text automatically), researched state laws affecting the business, prepared consultation briefs with specific questions and context, analyzed risk across multiple legal strategies. All from the terminal.

**Tax.** Compared 4 CPA options with specific criteria (crypto complexity, LLC structure, investment income). Organized uploaded documents. Tracked deadlines.

**Insurance.** Researched carrier options after one rejected the business. Compared coverage types, estimated premium ranges for the new business model, identified specific policy exclusions to negotiate on. Prepared questions for the broker.

**Domain &amp; brand research.** When considering a domain change, researched SEO/GEO implications, analyzed traffic sources (discovered ChatGPT was recommending the app as one of 5 in its category — hidden in "direct" traffic), modeled the impact of a 301 redirect over 12 months.

None of this is code. It's research, synthesis, document management, and decision support. The same terminal, the same personality, the same workflow.

---

## Data &amp; Analytics

**Local analytics replica.** 125K rows synced from the production database into a local SQLCipher encrypted copy in 11 seconds. Python query library with methods for funnel analysis, archetype distribution, traffic sources, daily summaries. Ad-hoc SQL via `make quiz-analytics-query SQL="..."`.

**Traffic forensics.** Investigated a traffic spike: traced 46% to a 9-month-old Reddit post, discovered ChatGPT referrals were hiding in "direct" traffic (45%). One Reddit post was responsible for 551 sessions.

**Survey analysis.** 573 responses from a 3-question post-quiz survey. Cross-tabulated motivation vs. experience level vs. biggest challenge. 

---

## Self-Improvement Loop

This is the part that compounds.

**Session wrap-up.** Every session ends with `/wrap-up`: commit code, update memory, update status docs, run a quick retro scan. The retro checks for repeated issues, compliance failures, and patterns. If it finds something mechanical being handled with prose instructions, it flags it: "This should be a script, not more guidance."

**Deep retrospective.** Periodically run `/retro-deep` — forensic analysis of an entire session. Every issue, compliance gap, workaround. Saves a report, auto-applies fixes.

**Memory management.** Patterns confirmed across multiple sessions get saved. Patterns that turn out wrong get removed. The memory file stays under 200 lines — concise, not comprehensive.

**Rules from pain.** Every rule in the system traces back to something that broke. The plan-execution pre-check exists because I re-applied a plan that was already committed. The bash safety guard exists because Claude tried to `rm` something. The PDF hook exists because a 33-page PDF ate 50K tokens. Pain -&gt; rule -&gt; never again.

---

## The Meta

Here's the thing that's hard to convey in a feature list: all of this happens in one terminal, in one conversation, with one personality that has context on everything.

I don't context-switch between "coding tool" and "business advisor" and "content writer." I talk to Jules. Jules knows the codebase, the business context, the content voice, the pending decisions, and yesterday's session. The 116 configurations aren't 116 things I interact with. They're the substrate that makes it feel like working with a really competent colleague who never forgets anything.

A typical day touches 4-5 of these categories. Monday I might deploy a feature, analyze survey data, draft a LinkedIn post, and prep for a legal consultation. All in one session. The morning briefing tells me what needs attention, voice dictation routes work to the right depth, and wrap-up captures what happened so tomorrow's briefing is accurate.

That's what I actually do with it.

---

*This is part of a series. The previous post covers the full setup audit. Deeper articles on hooks, the morning briefing, the personality layer, and review cycles are queued. If there's a specific workflow you want me to break down further, say so in the comments.*

*Running on an M4 MacBook with Claude Code Max. The workspace is a single git repo. Happy to answer questions.*


id: ee5225ede58c
title: Show HN: A context-aware permission guard for Claude Code
source_url: https://github.com/manuelschipper/nah/
source_platform: hackernews
author: schipperai
published_at: 2026-03-11T23:26:25+00:00
collected_at: 2026-03-12T01:04:01.291231+00:00
scenario_type: 终端与CLI增强
tools_used: ["Claude Code", "PreToolUse hook", "Python", "git"]
novelty: similar
similar_to_ids: ["b3c98201ebeb", "129d264430ea"]
summary:
nah是Claude Code的权限管理工具，通过确定性分类器在毫秒级别内对每个工具调用进行分类（文件系统读写、包运行、数据库操作等），应用精细化的权限策略（允许/上下文相关/询问/阻止），在无需复杂配置的情况下防止恶意操作。该解决方案兼具安全性和易用性，开箱即用且支持完全自定义。

raw_content:
Show HN: A context-aware permission guard for Claude Code

We needed something like --dangerously-skip-permissions that doesn’t nuke your untracked files, exfiltrate your keys, or install malware.<p>Claude Code&#x27;s permission system is allow-or-deny per tool, but that doesn’t really scale. Deleting some files is fine sometimes. And git checkout is sometimes not fine. Even when you curate permissions, 200 IQ Opus can find a way around it. Maintaining a deny list is a fool&#x27;s errand.<p>nah is a PreToolUse hook that classifies every tool call by what it actually does, using a deterministic classifier that runs in milliseconds. It maps commands to action types like filesystem_read, package_run, db_write, git_history_rewrite, and applies policies: allow, context (depends on the target), ask, or block.<p>Not everything can be classified, so you can optionally escalate ambiguous stuff to an LLM, but that’s not required. Anything unresolved you can approve, and configure the taxonomy so you don’t get asked again.<p>It works out of the box with sane defaults, no config needed. But you can customize it fully if you want to.<p>No dependencies, stdlib Python, MIT.<p>pip install nah &amp;&amp; nah install<p><a href="https:&#x2F;&#x2F;github.com&#x2F;manuelschipper&#x2F;nah" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;manuelschipper&#x2F;nah</a>


id: fa99bccccb57
title: Show HN: Hyper – A stupidly non-corporate voice AI app for IRL conversations
source_url: https://apps.apple.com/us/app/hyper-ai-for-real-talk/id6760206718
source_platform: hackernews
author: shainvs
published_at: 2026-03-11T18:39:29+00:00
collected_at: 2026-03-12T01:04:09.821084+00:00
scenario_type: 个人知识管理
novelty: similar
similar_to_ids: ["1af6cd68ee76", "3efa09430c4d"]
summary:
Hyper是一款iOS语音记录应用，专为捕捉非正式但重要的对话设计，支持实时转录、结构化摘要和可操作项目提取。该应用通过内置唤醒词检测和多工具集成（日历、邮件等），帮助用户构建长期对话记忆库并快速检索信息，解决传统会议工具无法捕捉走廊对话等非结构化讨论的问题。

tools_used:
["iOS Voice Recorder", "Real-time Transcription", "On-device Wakeword Detection", "Calendar Integration", "Gmail Integration", "Reminder System", "Email Draft Generation"]

raw_content:
Show HN: Hyper – A stupidly non-corporate voice AI app for IRL conversations

Hey HN, we&#x27;re building Hyper: an iOS voice recorder for the conversations that matter too much to pause and take notes. 1:1s with your cofounder, coffee chats, standups, whiteboard sessions. One tap to record, and when you&#x27;re done you get a summary, full transcript, and tappable action items (calendar events, reminders, email drafts) — no notes needed.<p>We built this because at our last company (a robotics startup), the most consequential decisions happened spontaneously — in hallways, over lunch, on walks. None of it got captured. Every recorder we tried was built for scheduled Zoom calls with agendas. We wanted something for the messy, unstructured conversations where the real work happens.<p>How it works: Hyper transcribes your conversations in real-time. On-device wakeword detection lets you ask it questions mid-conversation with “hey hyper” or via chat without breaking flow — &quot;wait, what did we decide about the deadline last time?&quot; — and it pulls from every past conversation. After the meeting, another agent extracts structured actions and maps them to the rest of your tools (like Calendar, GMail, and native iOS integrations).<p>The bet we&#x27;re making: existing meeting tools stop at &quot;here&#x27;s a document.&quot; We believe people don&#x27;t want better documents from their meetings, they want answers to their questions.<p>We envision a future where people can simply ask across all conversations and get the answer instantly — without files or folders or manual organization. We’re building out a long-term memory framework that lets Hyper resolve conflicting information, surface stale information, and help untangle the gnarliest of problems.<p>We&#x27;re two founders, currently self-funded, building in SF. We’d love for you to try it out in your next exciting conversation and to hear your feedback. Thanks!<p>-- Shalin &amp; Kanyes


id: faae7106be20
title: Show HN: Axe – A 12MB binary that replaces your AI framework
source_url: https://github.com/jrswab/axe
source_platform: hackernews
author: jrswab
published_at: 2026-03-12T13:49:12+00:00
collected_at: 2026-03-13T01:00:47.567000+00:00
scenario_type: 终端与CLI增强
tools_used: ["Axe", "TOML", "Unix pipes", "Git hooks", "CI/CD", "MCP", "Anthropic", "OpenAI", "Ollama"]
novelty: similar
similar_to_ids: ["77b4be38215d", "abb1b9505bb9", "b9d2abdd810b", "0b5c4741d1c1", "1d33fcd888f9"]
summary:
Axe是一个12MB的轻量级二进制工具，将LLM代理设计为Unix风格的可组合程序，支持通过CLI管道、Git钩子和cron作业触发特定任务。用户可以链接多个专注的代理（如代码审查、日志分析等）处理本地数据，无需传统AI框架的重量和复杂性。该工具强调小而精的设计哲学，实现了高度的本地自动化潜力。

raw_content:
Show HN: Axe – A 12MB binary that replaces your AI framework

I built Axe because I got tired of every AI tool trying to be a chatbot.<p>Most frameworks want a long-lived session with a massive context window doing everything at once. That&#x27;s expensive, slow, and fragile. Good software is small, focused, and composable... AI agents should be too.<p>Axe treats LLM agents like Unix programs. Each agent is a TOML config with a focused job. Such as code reviewer, log analyzer, commit message writer. You can run them from the CLI, pipe data in, get results out. You can use pipes to chain them together. Or trigger from cron, git hooks, CI.<p>What Axe is:<p>- 12MB binary, two dependencies. no framework, no Python, no Docker (unless you want it)<p>- Stdin piping, something like `git diff | axe run reviewer` just works<p>- Sub-agent delegation. Where agents call other agents via tool use, depth-limited<p>- Persistent memory. If you want, agents can remember across runs without you managing state<p>- MCP support. Axe can connect any MCP server to your agents<p>- Built-in tools. Such as web_search and url_fetch out of the box<p>- Multi-provider. Bring what you love to use.. Anthropic, OpenAI, Ollama, or anything in models.dev format<p>- Path-sandboxed file ops. Keeps agents locked to a working directory<p>Written in Go. No daemon, no GUI.<p>What would you automate first?


id: 4762c1e8251d
title: Show HN: Rudel – Claude Code Session Analytics
source_url: https://github.com/obsessiondb/rudel
source_platform: hackernews
author: keks0r
published_at: 2026-03-12T13:41:12+00:00
collected_at: 2026-03-13T01:00:56.325276+00:00
scenario_type: 数据分析与可视化
tools_used: ["Claude Code", "rudel.ai", "analytics platform"]
novelty: similar
similar_to_ids: ["75541a4dc03b"]
summary:
Rudel是一个为Claude Code会话设计的分析工具，通过收集1573个真实会话的15M+代币和270K+交互数据，提供了对代码会话效率、放弃率和成功率的深度洞察。该工具帮助用户理解哪些任务类型表现最佳，识别错误级联模式，并为AI代理会话性能建立基准。

raw_content:
Show HN: Rudel – Claude Code Session Analytics

We built rudel.ai after realizing we had no visibility into our own Claude Code sessions. We were using it daily but had no idea which sessions were efficient, why some got abandoned, or whether we were actually improving over time.<p>So we built an analytics layer for it. After connecting our own sessions, we ended up with a dataset of 1,573 real Claude Code sessions, 15M+ tokens, 270K+ interactions.<p>Some things we found that surprised us:
- Skills were only being used in 4% of our sessions
- 26% of sessions are abandoned, most within the first 60 seconds
- Session success rate varies significantly by task type (documentation scores highest, refactoring lowest)
- Error cascade patterns appear in the first 2 minutes and predict abandonment with reasonable accuracy
- There is no meaningful benchmark for &#x27;good&#x27; agentic session performance, we are building one.<p>The tool is free to use and fully open source, happy to answer questions about the data or how we built it.


id: aca7847db120
title: Show HN: OneCLI – Vault for AI Agents in Rust
source_url: https://github.com/onecli/onecli
source_platform: hackernews
author: guyb3
published_at: 2026-03-12T16:41:06+00:00
collected_at: 2026-03-13T01:01:04.549185+00:00
scenario_type: 商业流程自动化
tools_used: ["OneCLI", "Rust", "Next.js", "Docker", "PGlite", "AES-256-GCM", "HTTPS_PROXY"]
novelty: similar
similar_to_ids: ["383475726b14"]
summary:
OneCLI是一个开源的AI代理凭证管理网关，通过加密密钥库和HTTP代理拦截，在AI代理和外部服务间建立安全隔离层，使代理能够访问服务而无需持有真实凭证。该解决方案采用Rust构建、Docker单容器部署，支持多种代理框架，解决了AI代理安全性和凭证泄露的关键问题。

raw_content:
Show HN: OneCLI – Vault for AI Agents in Rust

We built OneCLI because AI agents are being given raw API keys. And it&#x27;s going about as well as you&#x27;d expect. We figured the answer isn&#x27;t &quot;don&#x27;t give agents access,&quot; it&#x27;s &quot;give them access without giving them secrets.&quot;<p>OneCLI is an open-source gateway that sits between your AI agents and the services they call. You store your real credentials once in OneCLI&#x27;s encrypted vault, and give your agents placeholder keys. When an agent makes an HTTP call through the proxy, OneCLI matches the request by host&#x2F;path, verifies the agent should have access, swaps the placeholder for the real credential, and forwards the request. The agent never touches the actual secret. It just uses CLI or MCP tools as normal.<p>Try it in one line:
docker run --pull always -p 10254:10254 -p 10255:10255 -v onecli-data:&#x2F;app&#x2F;data ghcr.io&#x2F;onecli&#x2F;onecli<p>The proxy is written in Rust, the dashboard is Next.js, and secrets are AES-256-GCM encrypted at rest. Everything runs in a single Docker container with an embedded Postgres (PGlite), no external dependencies. Works with any agent framework (OpenClaw, NanoClaw, IronClaw, or anything that can set an HTTPS_PROXY).<p>We started with what felt most urgent: agents shouldn&#x27;t be holding raw credentials. 
The next layer is access policies and audit, defining what each agent can call, logging everything, and requiring human approval before sensitive actions go through.<p>It&#x27;s Apache-2.0 licensed. We&#x27;d love feedback on the approach, and we&#x27;re especially curious how people are handling agent auth today.<p>GitHub: <a href="https:&#x2F;&#x2F;github.com&#x2F;onecli&#x2F;onecli" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;onecli&#x2F;onecli</a>
Site: <a href="https:&#x2F;&#x2F;onecli.sh" rel="nofollow">https:&#x2F;&#x2F;onecli.sh</a>


id: 61a57c93de29
title: punkpeye/awesome-mcp-servers
summary: 这是一个MCP服务器的集合项目，用于汇总和展示各种可用的MCP(Model Context Protocol)服务器资源。虽然提供了有用的工具索引，但缺乏具体的使用场景说明和实际应用示例。
source_url: https://github.com/punkpeye/awesome-mcp-servers
source_platform: github
author: punkpeye
published_at: 2026-03-12T21:46:29+00:00
collected_at: 2026-03-13T01:01:11.006111+00:00
scenario_type: 其他
tools_used: ["MCP servers"]
novelty: new
similar_to_ids: []
raw_content:
punkpeye/awesome-mcp-servers

A collection of MCP servers.

Topics: ai, mcp
Language:  | Stars: 82922


id: bea33498d6bd
source_platform: reddit
author: unknown
published_at: 2026-03-13T01:00:14.978883+00:00
collected_at: 2026-03-13T01:01:25.448548+00:00
scenario_type: 工作流自动化
novelty: similar
similar_to_ids: ["4188cb874081", "9d622833f3fc", "93d2c2bcd5d9", "6885ba6c5ca2", "5471379ee4ff"]
title:
I tested 9 ClawHub skills so you don't have to — here's what actually runs daily (with install commands) : r/OpenClawUseCases

summary:
本文介绍了9个经过实际测试的ClawHub技能，涵盖开发工作流、项目管理、浏览器自动化和知识库集成等多个场景。作者提供了具体的安装命令和使用案例，帮助用户快速构建高效的AI代理工作流自动化体系，特别适合需要多工具集成的开发团队。

source_url:
https://www.reddit.com/r/OpenClawUseCases/comments/1raculq/i_tested_9_clawhub_skills_so_you_dont_have_to/

tools_used:
["ClawHub", "GitHub", "AgentMail", "Linear", "Automation Workflows", "Monday.com", "Playwright Scraper", "Playwright MCP", "Obsidian"]

raw_content:
I tested 9 ClawHub skills so you don't have to — here's what actually runs daily (with install commands) : r/OpenClawUseCases

I tested 9 ClawHub skills so you don't have to — here's what actually runs daily (with install commands) : r/OpenClawUseCases Skip to main content I tested 9 ClawHub skills so you don't have to — here's what actually runs daily (with install commands) : r/OpenClawUseCases

Go to OpenClawUseCases

r/OpenClawUseCases 1d ago

EstablishmentSea4024

# I tested 9 ClawHub skills so you don't have to — here's what actually runs daily (with install commands)

ClawHub has 500+ skills now and honestly it's overwhelming. Spent time going through them and narrowed down the ones that actually get used on a regular basis vs. the ones that just sound cool but collect dust.

Here's my daily driver stack with the install commands:

---

**1. GitHub**

clawdhub install github

Essential for any dev workflow. Managed OAuth, handles repos/issues/PRs/commits. Your agent can open issues, review PRs, and search code without you touching the UI. If you do any coding work this is a must-have.

---

**2. AgentMail — email infrastructure for agents**

clawdhub install agentmail

This one is underrated. Creates real inboxes for your agents programmatically — great for handling verifications, managing separate agent identities, or letting your agent sign up for services autonomously. Bonus: running agents on isolated email accounts is a solid security practice.

---

**3. Linear — project management**

clawdhub install linear

GraphQL-based. Creates/updates issues, manages projects, teams, cycles — all from inside OpenClaw. Huge time saver if you're already using Linear for task tracking.

---

**4. Automation Workflows — workflow builder**

clawdhub install automation-workflows

Literally teaches your agent to build automation pipelines for you. Identifies repetitive tasks, sets up triggers and actions. Think of it as giving your agent a brain upgrade for process design.

---

**5. Monday — boards and task management**

clawdhub install monday

2.5k downloads so clearly people are using it. If your team runs on Monday.com this connects your agent directly to boards — creates items, updates statuses, manages tasks.

---

**6. Playwright Scraper — anti-bot web scraping**

clawdhub install playwright-scraper-skill

Actual browser automation that handles bot detection. When a basic HTTP request won't cut it and you need a real browser to get the data.

---

**7. Playwright MCP — full browser automation**

clawdhub install playwright-mcp

Navigates sites, clicks elements, fills forms, takes screenshots. Full end-to-end browser control. Pairs well with the scraper skill depending on your use case.

---

**8. Obsidian Direct — personal knowledge base**

clawdhub install obisdian-direct

Fuzzy search across your notes, auto-folder detection, manages tags and wikilinks. Your agent can query your Obsidian vault as a knowledge base. Huge if you're a heavy note-taker.

---

**9. NextJS 16+ Docs**

clawdhub install lb-nextjs16-skill

Entire NextJS 16 docs in markdown loaded into context. Stops the hallucinations when building/debugging Next projects.

---

**Quick install flow:**

npm i -g clawdhub

clawdhub search "skill-name"

clawdhub install skill-name

Skills load automatically once installed. OAuth skills (GitHub, Monday) need auth setup but it's straightforward.

---

**One security note:** Run your agent on an isolated machine or VPS with its own accounts. Don't hook it up to your main system from day one. Give it access to only what it needs — treat it like a new hire, not a trusted admin.

---

What skills are you running daily? Drop your stack below — curious what this community has found that I'm sleeping on.

Read more

Share

---

OverFlow10

1d ago

I like the Genviral skill as well (maybe helpful for those posting to socials like us)

1

EstablishmentSea4024

1d ago

exactly, I am also playing around to build custom X growth focus skill to push the limit of openclaw at https://x.com/takumi_tasiro. happy to connect and share more

1

Continue this thread

Reddit Rules Privacy Policy User Agreement Your Privacy Choices Accessibility Reddit, Inc. © 2026. All rights reserved.


id: 914bbf5c72c1
title: Workflow when switching between Cursor and Claude Code : r/vibecoding
source_platform: reddit
author: unknown
published_at: 2026-03-13T01:00:17.088822+00:00
collected_at: 2026-03-13T01:02:16.940034+00:00
scenario_type: 工作流自动化
tools_used: ["Cursor", "Claude Code", "ByteRover"]
novelty: similar
similar_to_ids: ["95b07c16360e", "4188cb874081", "53514a186429", "93d2c2bcd5d9"]
summary:
用户探讨在Cursor和Claude Code之间切换的工作流优化策略，以降低月度成本支出。社区建议通过标准化提示模板、使用内存层工具、以及在切换前生成上下文总结等方式，实现两个代码编辑工具间的无缝协作和高效切换。

source_url:
https://www.reddit.com/r/vibecoding/comments/1ph6sio/workflow_when_switching_between_cursor_and_claude/

raw_content:
Workflow when switching between Cursor and Claude Code : r/vibecoding

Workflow when switching between Cursor and Claude Code : r/vibecoding Skip to main content Workflow when switching between Cursor and Claude Code : r/vibecoding

Go to vibecoding

r/vibecoding 2mo ago

Kornfried

# Workflow when switching between Cursor and Claude Code

Hi folks,

Since I blow about between 1-1,5k€ a month on Cursor (including the ultra plan), I wanted to look into how I can leverage the Claude Code Max subscription to decrease the cost a bit. I'm really happy with how Cursor works for me, but it seems to me that for the same Models (Opus, Sonnet) the behavior is pretty different. Also, the process of passing the right context and commands between Claude and Cursor seems to be a bit different.

I'm sure I can manage with putting a bit of time in, but I wonder if there are some tips some of you have.

Share

---

alinarice

2mo ago

Feed context and rules freshly when switching, and standardize prompts or templates so yo don't lose consistency between Cursor and Claude Code. Focus on passing only the dynamic metadata each needs.

2

noctokun

2mo ago

I use a memory layer (currently ByteRover) to seamlessly swap between codex and Claude code. (I personally only have the $20 plan for codex and Claude code and swap when I max)

2

Davor_Suker_

2mo ago

Before switching ask whichever to give you a prompt to continue in a fresh session that summarizes what you have done and what is left to do and pointing at the right files for context (or to give you the right context in text). And then you start fresh in a new session.

If you burn past the usage cap just export the conversation with /export and your first prompt to the new one is, given the conversation I am now attaching/pasting give me (the prompt in my first paragraph). Take that prompt and again, start fresh

2

Reddit Rules Privacy Policy User Agreement Your Privacy Choices Accessibility Reddit, Inc. © 2026. All rights reserved.


id: 53435200c5ef
source_platform: reddit
author: unknown
published_at: 2026-03-13T01:00:17.088828+00:00
collected_at: 2026-03-13T01:02:30.838838+00:00
scenario_type: 工作流自动化
tools_used: ["Claude Opus 4.5", "Claude Opus 4.6", "Zapier", "n8n", "OpenClaw", "WhatsApp"]
novelty: similar
similar_to_ids: ["9d622833f3fc", "93d2c2bcd5d9", "b2c80ce8e19d", "914bbf5c72c1"]
title:
6 months of vibe coding with Opus 4.6: is OpenClaw actually worth the hype or can you build the same stuff yourself? (the FOMO is real) : r/vibecoding

summary:
用户分享了6个月使用Claude Opus进行"vibe coding"的经验,对比了OpenClaw等AI代理工具的价值。讨论涵盖自建自动化工具vs商用解决方案的权衡,包括成本、安全性和学习曲线等实际考量,反映了开发者在快速发展的AI工具生态中的选择困境。

source_url:
https://www.reddit.com/r/vibecoding/comments/1r6ec2e/6_months_of_vibe_coding_with_opus_46_is_openclaw/

raw_content:
6 months of vibe coding with Opus 4.6: is OpenClaw actually worth the hype or can you build the same stuff yourself? (the FOMO is real) : r/vibecoding

6 months of vibe coding with Opus 4.6: is OpenClaw actually worth the hype or can you build the same stuff yourself? (the FOMO is real) : r/vibecoding Skip to main content 6 months of vibe coding with Opus 4.6: is OpenClaw actually worth the hype or can you build the same stuff yourself? (the FOMO is real) : r/vibecoding

Go to vibecoding

r/vibecoding 4h ago

Lovemetenderforeverx

# 6 months of vibe coding with Opus 4.6: is OpenClaw actually worth the hype or can you build the same stuff yourself? (the FOMO is real)

Hey everyone,

I've been vibe coding for about 8 months now and honestly having a blast. Currently building a custom tool for YouTube animations and a complete Data Intelligence Hub serving multiple companies, all with Claude Opus 4.5 and 4.6. On the automation side I'm using tools like Zapier and n8n to connect everything together. But in most of cases not even necessary !

So when OpenClaw went viral I obviously looked into it and my first thought was... can't I just build this myself?

Like, I get it the idea of texting an AI agent on WhatsApp that manages your calendar, books flights, and runs shell commands is cool as hell. But if you're already vibe coding with Opus 4.6 and stitching things together with Zapier/n8n, aren't you basically building your own version of this? One that you actually understand and control? Or am I completely missing something here?

And then there's the cost issue. OpenClaw is "free and open source" but you still need to bring your own API keys. And if you're running it on Claude (which most people seem to recommend for best results), those API costs are absolutely brutal. You can't just use your regular Claude Pro subscription , you need actual API credits. And the burn rate when you're testing, iterating, and letting an autonomous agent run tasks? Insane. We're talking potentially hundreds of dollars just experimenting. Unless you're using proxies or workarounds (which feels sketchy), how are people actually affording this? Genuinely curious how you all manage the costs.

On top of that, the security concerns are no joke. This thing needs access to your email, calendar, messaging apps, file system... Cisco already found third-party skills doing data exfiltration without users knowing. One of OpenClaw's own maintainers literally said if you can't understand command line, this project is too dangerous for you. That's... not exactly reassuring for mainstream use.

But the FOMO is real. 145k+ GitHub stars, OpenAI just acquired the creator, everyone's talking about it. Things are moving SO fast that by the time I figure out one tool, three new ones have dropped. I don't want to chase every shiny thing, but I also don't want to miss the boat on something actually transformative.

So for those of you who've tried OpenClaw, what's your honest take? What can it actually do that a solid vibe coding setup with Claude + Zapier/n8n can't? And how the hell are you managing the API costs?

Would love to hear your real experiences, not just the hype. 🙏

Read more

Share

---

ChanceKale7861

4h ago

Don’t lose yourself to the hype!

Find your domain, the problems you know you can solve, and focus there. but trying to keep up or catchup is pointless and unnecessary.

The dude who made openclaw has done other things of note, so this was one more project for him.

If you are just focused on all the hype, you will miss the real innovations that you or anyone else with domain expertise can bring to the table.

Finally, YES YOU CAN BUILD MOST WRAPPERS yourself. That’s why we have the market selloff. But the pushback from many is “but you can’t vibe code enterprise software,” yet, why would you WANT to build enterprise software? Most have many of the same issues as openclaw, but they are publicly traded so… there’s that…

You have a chance to build BETTER than this AND openclaw. Further, it’s not as if they are the first to focus on agent scaling… I’d say build with Agno and focus on agentOS as the basis to build on top of which actually does address runtime aspects such as security.

6

UrAn8

4h ago

The idea of it being open source is where the magic is. you can literally fork it and save yourself tons of time by building on top of it, including connecting zapier or n8n workflows.

it's not a polished product meant for mass distribution. its a shiny for devs that will serve as the foundation for tons of business ideas and personal projects.

3

cumin_guzzler

4h ago

I came to a decision that it’s all over juiced

2

Yixn

4h ago

OpenClaw is worth it if you want a persistent agent that runs 24/7, remembers context across sessions, and integrates with messaging apps. Can you build the same thing yourself? Technically yes, but you'd be reinventing months of work. The value is in the batteries-included setup: memory, heartbeats, multi-channel, skills system. If you just want to try it without the setup hassle, https://ClawHosters.com does managed hosting (€19/mo). But honestly, self-hosting is fine too if you're comfortable with VPS stuff.

-2

MortalJohn

3h ago

What's it like coding? Can you use it like a copilot like cursor or vscode chat? These services have been great for me, but I'm wary of my token usage spiking and the cost is already crazy.

1

Chupa-Skrull

3h ago

You're responding to a marketing bot

1

1 more reply

Continue this thread Continue this thread Continue this thread

Reddit Rules Privacy Policy User Agreement Your Privacy Choices Accessibility Reddit, Inc. © 2026. All rights reserved.


id: f04f8a6aa88f
title: Show HN: LogClaw – Open-source AI SRE that auto-creates tickets from logs
source_url: https://logclaw.ai
source_platform: hackernews
author: Robelkidin
published_at: 2026-03-12T17:06:42+00:00
collected_at: 2026-03-13T01:02:55.667284+00:00
scenario_type: 商业流程自动化
novelty: similar
similar_to_ids: ["9e6735e3c6a2", "383475726b14"]
summary:
LogClaw是一个开源的AI SRE平台，通过OpenTelemetry摄取日志并使用信号复合评分检测异常，自动生成上下文丰富的故障工单到多个平台（Jira、ServiceNow、PagerDuty等），显著减少人工告警处理负担。该系统通过5层日志关联引擎追踪错误传播，支持本地Kubernetes部署和云端管理服务，从日志到工单创建仅需约90秒，可替代Datadog等商业监控解决方案。

tools_used:
["LogClaw", "OpenTelemetry", "Kafka", "OpenSearch", "Jira", "ServiceNow", "PagerDuty", "OpsGenie", "Slack", "Zammad", "OpenAI", "Claude", "Ollama", "Kubernetes", "Helm"]

raw_content:
Show HN: LogClaw – Open-source AI SRE that auto-creates tickets from logs

Hi HN, I&#x27;m Robel. I built LogClaw because I was tired of paying for Datadog and still waking up to pages that said &quot;something is wrong&quot; with no context.<p>LogClaw is an open-source log intelligence platform that runs on Kubernetes. It ingests logs via OpenTelemetry and detects anomalies using signal-based composite scoring — not simple threshold alerting. The system extracts 8 failure-type signals (OOM, crashes, resource exhaustion, dependency failures, DB deadlocks, timeouts, connection errors, auth failures), combines them with statistical z-score analysis, blast radius, error velocity, and recurrence signals into a composite score. Critical failures (OOM, panics) trigger the immediate detection path in &lt;100ms — before a time window even completes. The detection achieves 99.8% for critical failures while filtering noise (validation errors and 404s don&#x27;t fire incidents).<p>Once an anomaly is confirmed, a 5-layer trace correlation engine groups logs by traceId, maps service dependencies, tracks error propagation cascades, and computes blast radius across affected services. Then the Ticketing Agent pulls the correlated timeline, sends it to an LLM for root cause analysis, and creates a deduplicated ticket on Jira, ServiceNow, PagerDuty, OpsGenie, Slack, or Zammad. The loop from log noise to a filed ticket is about 90 seconds.<p>Architecture: OTel Collector → Kafka (Strimzi, KRaft mode) → Bridge (Python, 4 concurrent threads: ETL, anomaly detection, OpenSearch indexing, trace correlation) → OpenSearch + Ticketing Agent. The AI layer supports OpenAI, Claude, or Ollama for fully air-gapped deployments. Everything deploys with a single Helm chart per tenant, namespace-isolated, no shared data plane.<p>To try it locally:
<a href="https:&#x2F;&#x2F;docs.logclaw.ai&#x2F;local-development" rel="nofollow">https:&#x2F;&#x2F;docs.logclaw.ai&#x2F;local-development</a><p>What it does NOT do yet:
- Metrics and traces — this is logs-only right now. Metrics support is on the roadmap.
- The anomaly detection is signal-based + statistical (composite scoring with z-score), not deep learning. It catches 99.8% of critical failures but won&#x27;t detect subtle performance drift patterns yet.
- The dashboard is functional but basic. We use OpenSearch Dashboards for the heavy lifting.<p>Licensed Apache 2.0. The managed cloud version is $0.30&#x2F;GB ingested if you don&#x27;t want to self-host.<p>Hi HN — I’m Robel.
I built LogClaw after getting tired of waking up to alerts that only said “something is wrong” with no context.
LogClaw is an open-source log intelligence platform for Kubernetes. It ingests logs via OpenTelemetry and detects operational failures using signal-based anomaly detection rather than simple thresholds.
Instead of looking at a single metric, LogClaw extracts failure signals from logs (OOMs, crashes, dependency failures, DB deadlocks, timeouts, etc.) and combines them with statistical signals like error velocity, recurrence, z-score anomalies, and blast radius to compute a composite anomaly score.
Critical failures bypass time windows and trigger detection in &lt;100ms.
Once an anomaly is confirmed, a correlation engine reconstructs the trace timeline across services, detects error propagation, and computes the blast radius.
A ticketing agent then generates a root-cause summary and creates deduplicated incidents in Jira, ServiceNow, PagerDuty, OpsGenie, Slack, or Zammad.
Architecture:
OTel Collector → Kafka → Detection Engine → OpenSearch → Ticketing Agent
Repo:
<a href="https:&#x2F;&#x2F;github.com&#x2F;logclaw&#x2F;logclaw" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;logclaw&#x2F;logclaw</a>
Would love feedback from people running large production systems.


id: 220851dd1119
source_platform: reddit
author: unknown
published_at: 2026-03-13T01:00:19.459590+00:00
collected_at: 2026-03-13T01:03:22.638442+00:00
scenario_type: 工作流自动化
tools_used: ["Claude Code", "tmux", "bash", "markdown"]
novelty: similar
similar_to_ids: ["4188cb874081", "53514a186429", "6fe122c430d7", "e9cce03581a0"]
title:
I built a zero-dependency multi-agent pipeline for Claude Code — Opus plans, Sonnet codes, Haiku tests. Super lightweight and runs using only tmux and bash. Drop it into any project with one command. : r/ClaudeAI

summary:
用户构建了一个零依赖的多智能体管道系统，通过tmux和bash协调多个Claude Code实例（Opus规划、Sonnet编码、Haiku测试）自动完成任务流程。该系统支持灵活的配置和多种工作流模式，可一键部署到任何项目中，显著提高团队协作效率和开发自动化程度。

source_url:
https://www.reddit.com/r/ClaudeAI/comments/1r7wq0d/i_built_a_zerodependency_multiagent_pipeline_for/

raw_content:
I built a zero-dependency multi-agent pipeline for Claude Code — Opus plans, Sonnet codes, Haiku tests. Super lightweight and runs using only tmux and bash. Drop it into any project with one command. : r/ClaudeAI

I built a zero-dependency multi-agent pipeline for Claude Code — Opus plans, Sonnet codes, Haiku tests. Super lightweight and runs using only tmux and bash. Drop it into any project with one command. : r/ClaudeAI Skip to main content I built a zero-dependency multi-agent pipeline for Claude Code — Opus plans, Sonnet codes, Haiku tests. Super lightweight and runs using only tmux and bash. Drop it into any project with one command. : r/ClaudeAI

Go to ClaudeAI

r/ClaudeAI 3d ago

Snoo-30257

# I built a zero-dependency multi-agent pipeline for Claude Code — Opus plans, Sonnet codes, Haiku tests. Super lightweight and runs using only tmux and bash. Drop it into any project with one command.

I've been experimenting with running multiple Claude Code instances as a coordinated team, and I turned it into an open-source toolkit anyone can drop into any project.

You run one command, and it spins up a tmux session with multiple Claude Code instances, each assigned a specific role and model. They communicate through shared markdown files using an append-only protocol, and a background orchestrator automatically triggers each agent when the pipeline state changes.

The default setup is 3 agents:- 🏗️ **Manager (Opus)** — breaks down your goal into tasks, writes specs, reviews results- 💻 **Coder (Sonnet)** — reads the spec, implements it, logs what it did- 🧪 **Tester (Haiku)** — reviews the code, runs tests, reports pass/fail

The orchestrator watches a status file and auto-triggers the next agent in the chain. So you tell Opus "build me X" and then watch it plan → code → test → approve/revise in a loop, hands-free.

Some additional modes:- 2-agent mode (Manager + Coder, no tester)- 5-agent mode (adds Security Analyst + Docs Writer)- 6-agent mode (adds Senior Dev + Junior Dev split)- Custom agent profiles — define your own roles- Configurable models per role — swap any agent to any model- Stop/resume — context persists in markdown files, agents catch up automatically- Cycle limits and cooldowns — respects rate limits on Pro/Max plans- Auto-archiving — keeps context files small to save tokens (configurable)- Multiple tmux layouts — horizontal, vertical, or tiled

It can be installed with one line and dropped into any directory. Super useful when give high level gameplan documents with many steps or even building features with distinct sub steps. Just point it in a direction and let the pipeline run!

git clone https://github.com/GrIlm14/claude-agents.git~/claude-agents && chmod +x ~/claude-agents/setup.sh ~/claude-agents/scripts/pipeline.sh

Then in any project:

~/claude-agents/setup.sh./claude-pipeline auto

**The tech is simple on purpose** — no frameworks, no Python dependencies, no API wrappers. Just bash, tmux, and markdown. The agents coordinate through `.context/` files that act as an inter-agent communication protocol.

I've been using this on a real project (full-stack web app) and it legitimately runs autonomous development cycles. The orchestrator handles handoffs, Opus catches test failures and rewrites the spec, and the loop continues. It's a ton of fun to sit back and watch the agents go to work!

**This is open source and I'd love feedback:**- What agent roles would you add?- How would you improve the orchestration?- Anyone want to test this on macOS/native Linux?- Ideas for smarter rate limit handling?- How else could I improve upon this?

GitHub: https://github.com/GrIlm14/claude-agents

Works with Claude Pro, Max, or API keys. Requires WSL2 (Windows), or native Linux/macOS, plus tmux and Claude Code CLI.

Happy to answer any questions about the architecture or implementation. This is my first experiment with ai workflows, and it's been a ton of fun setting this up. Let me know what you think!

Read more

Share

---

• Promoted

Everything for work. In one place.

---

Sea_Refuse_5439

3d ago

this is pretty close to what i've been seeing work well in practice. the append-only markdown protocol is a smart call because it sidesteps the biggest failure mode i've noticed with multi-agent setups, which is agents overwriting each other's context and losing track of decisions made earlier in the chain.

one thing i'd flag from my own experiments: the opus-as-planner step is where most of the value comes from, but it's also where the biggest token waste happens if the spec isn't tight enough. i found that adding a constraint to the manager like "spec must fit in under 400 words" forces it to be surgical, and downstream agents actually perform better with less ambiguity. might be worth testing as a default.

curious how you're handling the case where haiku flags a test failure but the root cause is actually in the spec, not the code. does opus re-evaluate its own plan or does it just ask sonnet to retry? that loop logic is where these pipelines usually get stuck burning cycles.

1

Snoo-30257

2d ago

Love the length constraint idea. I could definitely add that as a config option in the pipeline and claude files.

On the failure loop, opus does reevaluate the plan, not just keep retrying. The orchestrator sends Opus the test results (from haiku), and opus can decide whether the problem is spec or implementation. If spec, opus rewrites it before setting PLAN_READY. If implementation, it gives specific fix instructions to sonnet.

Also, the current safety net is the MAX_CYCLES constraint which stops after N cycles to prevent burn. Any ideas on how I could improve this? Maybe monitoring when a task fails N amount of times consecutively, then escalate accordingly?

1

Continue this thread

BC_MARO

3d ago

Append-only markdown as the IPC layer is a good call - avoids the whole "who overwrote what" problem you get with shared state. The tmux + bash approach is refreshing too, way too many agent frameworks that need 15 dependencies just to get started. One thing worth watching: context file growth. Even with archiving, if Opus generates verbose specs the downstream agents start eating tokens fast on the re-reads.

1

Snoo-30257

2d ago

The auto archiving system handles context growth pretty well in testing. Opus summarizes any log files over 100 lines into the archive and trims the originals down to 20 lines (can adjust these thresholds as well). I've had this pipeline working on a pretty complex full stack web app, and it's performed better than I originally expected. I might play around with different values there (maybe like 250:50 next).

The append only methodology has been solid. Agents only reference the previous timestamp instead of copying, so there's less duplication there.

Any ideas on the spec verbosity? I'm sure setting a threshold (ie 400 words) could work in practice. I'm just not sure how much variation that could add down the line. Could possibly even have the manager assign different thresholds based on task complexity.

2

BC_MARO

2d ago

The dynamic threshold idea (manager assigns based on task complexity) is actually the better approach. A flat 400-word cap makes sense for simple CRUD tasks but kills fidelity on something like a database migration or multi-service refactor where implementation details actually matter.

One pattern that works well: let the manager annotate tasks with a verbosity class (minimal / standard / detailed) at dispatch time, and have Opus use that as a constraint. The complexity signal can come from a quick pre-pass heuristic - estimated file count, number of services touched, novelty vs similar past tasks. You get compression where it doesn't hurt and detail where it does.

1

Continue this thread Continue this thread

---

## View Post in

हिन्दी

Português (Brasil)

Reddit Rules Privacy Policy User Agreement Your Privacy Choices Accessibility Reddit, Inc. © 2026. All rights reserved.


id: fe0e6bfdbdd5
title: patchy631/ai-engineering-hub
summary: 这是一个关于LLM、RAG和AI代理应用的深度教程库，通过Jupyter Notebook呈现实际案例。资源涵盖机器学习工程的多个方面，对于学习和参考AI工程实践具有较高价值。
source_url: https://github.com/patchy631/ai-engineering-hub
source_platform: github
author: patchy631
published_at: 2026-03-12T13:26:06+00:00
collected_at: 2026-03-13T01:03:29.629475+00:00
scenario_type: 个人知识管理
tools_used: ["LLMs", "RAG", "MCP", "Jupyter Notebook"]
novelty: new
similar_to_ids: []
raw_content:
patchy631/ai-engineering-hub

In-depth tutorials on LLMs, RAGs and real-world AI agent applications.

Topics: agents, ai, llms, machine-learning, mcp, rag
Language: Jupyter Notebook | Stars: 31814


id: 02721bcb67a2
title: Show HN: I built an SDK that scrambles HTML so scrapers get garbage
source_url: https://www.obscrd.dev/
source_platform: hackernews
author: larsmosr
published_at: 2026-03-12T13:27:53+00:00
collected_at: 2026-03-13T01:03:37.947995+00:00
scenario_type: 代码生成与审查
tools_used: ["TypeScript", "Bun", "tsup", "React 18+", "CSS (flexbox, RTL, unicode-bidi)", "Canvas API"]
novelty: new
similar_to_ids: []
summary:
开发者构建了一个开源SDK，通过CSS视觉欺骗技术（字符打乱、flexbox重排等）使爬虫获取的HTML文本变为乱码，同时保持浏览器正常渲染。该方案包含邮箱混淆、AI蜜罐、剪贴板拦截等多层防护，目的是提高简单HTTP爬虫的成本，但承认无法阻挡执行CSS的无头浏览器。

raw_content:
Show HN: I built an SDK that scrambles HTML so scrapers get garbage

Hey HN -- I&#x27;m a solo dev. Built this because I got tired of AI crawlers reading my HTML in plain text while robots.txt did nothing.<p>The core trick: shuffle characters and words in your HTML using a seed, then use CSS (flexbox order, direction: rtl, unicode-bidi) to put them back visually. Browser renders perfectly. textContent returns garbage.<p>On top of that: email&#x2F;phone RTL obfuscation with decoy characters, AI honeypots that inject prompt instructions into LLM scrapers, clipboard interception, canvas-based image rendering (no img src in DOM), robots.txt blocking 30+ AI crawlers, and forensic breadcrumbs to prove content theft.<p>What it doesn&#x27;t stop: headless browsers that execute CSS, screenshot+OCR, or anyone determined enough to reverse-engineer the ordering. I put this in the README&#x27;s threat model because I&#x27;d rather say it myself than have someone else say it for me. The realistic goal is raising the cost of scraping -- most bots use simple HTTP requests, and we make that useless.<p>TypeScript, Bun, tsup, React 18+. 162 tests. MIT licensed. Nothing to sell -- the SDK is free and complete.<p>Best way to understand it: open DevTools on the site and inspect the text.<p>GitHub: <a href="https:&#x2F;&#x2F;github.com&#x2F;obscrd&#x2F;obscrd" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;obscrd&#x2F;obscrd</a>


id: 4cbcc14ad9be
title: What 5 months of nonstop Claude Code taught me : r/ClaudeAI
source_url: https://www.reddit.com/r/ClaudeAI/comments/1r6cn6t/what_5_months_of_nonstop_claude_code_taught_me/
source_platform: reddit
author: unknown
published_at: 2026-03-13T01:00:19.459594+00:00
collected_at: 2026-03-13T01:03:46.462964+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude Code", "Claude Max", "agentops", "Go CLI", "Skills plugin", "Codex", "Cursor"]
novelty: similar
summary:
用户分享了5个月使用Claude Code的经验，发现上下文窗口管理是关键。他构建了一个开源插件agentops，采用DevOps管道思想将编码任务分阶段处理，通过知识飞轮自动提取和注入历史学习，显著提升了AI辅助编码的效率和一致性。

similar_to_ids:
["1f770ae13aa5", "5b6f4e63a641", "8d0142693489", "c22de644b867", "19e007cf2bb9", "4e8f450b17be", "c4c047193758"]

raw_content:
What 5 months of nonstop Claude Code taught me : r/ClaudeAI

What 5 months of nonstop Claude Code taught me : r/ClaudeAI Skip to main content What 5 months of nonstop Claude Code taught me : r/ClaudeAI

Go to ClaudeAI

r/ClaudeAI 1d ago

_Bo_Knows

# What 5 months of nonstop Claude Code taught me

I've spent way too much money on Claude Code; three Max accounts for 5 months, work and personal. But it's made me so much more efficient I can't stop.

Here's the main thing I've learned: it's the context window, not the model. When your agent does everything in one conversation, the window fills up with stuff it doesn't need by the time it's actually writing code. That's why results are inconsistent.

I come from DevOps, so I started treating my agent like a pipeline; isolated stages, validated gates, fresh context at each phase. Then I built a knowledge flywheel on top so each session compounds on the last. Learnings get extracted automatically, indexed, scored, and injected back into the next session. You can search across all your past chat histories and knowledge artifacts.

I packaged it all into an open-source plugin. Composable primitives you wire together however you want. Use one skill or all of them. And the knowledge flywheel means session 10 has context session 1 didn't:

/research — Explores your codebase, writes findings to a file

/plan — Decomposes into issues with dependency waves

/pre-mortem — Fresh judges validate the plan before you code

/crank — Parallel workers, isolated context, lead validates and commits

/vibe — Fresh judges validate the code, not the conversation

/post-mortem — Extracts learnings, suggests what to build next

/rpi "goal" — Chains all six, one command, walk away

/council — Multi-model review on anything, zero setup

/evolve — Define repo goals, it keeps improving until they're green

Skills chain together and invoke a Go CLI automatically through hooks — knowledge injection, transcript mining, validation gates, the whole flywheel. You don't configure any of it.

```
npx skills@latest add boshu2/agentops --all -g
```

`/quickstart` in Claude Code. Works with Codex, Cursor, anything supporting Skills. Everything local.

github.com/boshu2/agentops

Feedback welcome.

Read more

Share

---

• Promoted

The everything app, for work. Get everyone working in a single platform designed to manage any type of work.

---

ClaudeAI-mod-bot

7h ago

TL;DR generated automatically after 50 comments.

Looks like the hive mind is in total agreement on this one. The consensus is that OP is spot on: the key to effective coding with Claude is aggressively managing the context window. One long, rambling chat is a surefire way to get inconsistent, garbage results. The pro move is to treat your workflow like a pipeline, breaking it into distinct stages with fresh context for each one.

OP packaged this philosophy into an open-source tool,`agentops`, but the thread quickly became a battle royale of similar frameworks.

The top comment is screaming from the rooftops about BMAD-METHOD, calling it an "absolute game changer."

GSD (Get-Shit-Done) was also brought up a lot. OP says their tool is more like modular infrastructure, while GSD is a more rigid, step-by-step pipeline.

Other tools like the Compound Engineering Plugin and a user's own Structured Context Specification (SCS) also made an appearance.

A few other nuggets of wisdom from the comments: keep your codebase clean of dead code to reduce context noise, and yes, some of you are rightfully paranoid about the security of running these tools on private repos.

1

meccaleccahimeccahi

1d ago

You need to checkout https://github.com/bmad-code-org/BMAD-METHOD It has been an absolute game changer for me. And I mean from concept to enterprise grade, it can do it all.

46

biotech-redditor

19h ago

how does it compare with https://github.com/gsd-build/get-shit-done

3

_Bo_Knows

18h ago

GSD is a pipeline. You follow its steps: describe, plan, execute, verify. It works well for that.

AgentOps is infrastructure. Composable primitives you wire together however you want. Use one skill or all of them. And the knowledge flywheel means session 10 has context session 1 didn't.

GSD tells the agent what to do. AgentOps makes the agent better at whatever it's already doing

6

3 more replies

Continue this thread Continue this thread

bonisaur

16h ago

I use Claude but I can't help but not just outright using some of the tools I've seen shared due to security and privacy concerns. Am I being too paranoid?

3

_Bo_Knows

1d ago

Thanks! I'll check it out.

2

Alex_1729

21h ago

Can this be used with Codex CLI?

2

1 more reply

Continue this thread Continue this thread

benevolent001

1d ago

How you solve the big picture `town planning` problem instead of making `one house `using this tool?

6

_Bo_Knows

1d ago

You spend time upfront defining the town: brainstorming, research, product definition, building the full roadmap of goals. Then /evolve grinds through repeated RPI cycles toward those goals, one house at a time. Each cycle compounds learnings into the next. The graph is always there, you're just executing against it incrementally.

4

2 more replies

Continue this thread

• Promoted

Put ChatGPT, Gemini, Claude in a room and see what happens.

thurn2

1d ago

Wow, this is astonishingly similar to my own workflow, I even have a `/metacognize` command which mirrors your `/post-mortem` (I hate beads, though, so I just use Claude's own task system).

Do you also have a ton of problems with the limitation where subagents cannot spawn their own subagents? It's extremely annoying because I always want to keep the orchestrator context small, but there's no way to do something like "spawn a researcher to look into this which can make its own research sub-agents" or "spawn a code reviewer that can make child code reviewers to look at different perspectives", it all needs to be routed through the orchestrator which burns a lot of context unnecessarily,.

3

_Bo_Knows

1d ago

Glad to see that we arrived at similar validation steps. I got around it get around it three ways depending on context: distributed mode runs each agent as its own top-level Claude Code process in tmux (no nesting at all), Agent Teams spawn agents as flat peers instead of nested children (depth resets), and RPI avoids the problem entirely by running sequential phases of flat parallel waves where agents share work through file artifacts instead of parent context.

3

Deep_Ad1959

1d ago

yeah the nesting limitation is why I gave up on subagents entirely. I just run 5 separate claude code processes in parallel on the same repo, each gets a fresh context with just the CLAUDE.md spec. the orchestrator is me reading diffs. sounds dumb but it ships faster than any automated orchestration I've tried.

3

Continue this thread

Lil_Twist

1d ago

I think I like that his is thought out a little more than how I go about it. I’ll will try this, see how I can evolve with it or provide feedback, if any.

Also, it’s been expressed more recently that the Claude.md file should be updated continually to grow with the project, curious if these skills work to always update and reforge / refactor such file(s).

3

1 more reply

Continue this thread

Reebzy

20h ago

Looks good and related to the popular compound-engineering plugin. Do you think they can work-hand-in-hand or is your workflow opinionated in a different way?

https://github.com/EveryInc/compound-engineering-plugin

3

_Bo_Knows

20h ago

Wow! Never heard of this, but mine for sure resembles this. From looking at it, all the steps of my workflow can work hand and hand. We both use worktrees and seem to isolate context per phase. I think a slight difference is that I spend more cycles on validation before implementation, but fundamentally the same.

2

Reebzy

19h ago

Great minds think alike as they say!

2

Continue this thread Continue this thread

JWPapi

22h ago

This matches my experience exactly. The thing I'd add: the codebase itself degrades over time in ways that make Claude worse. Dead exports from refactored code, duplicate utility functions from different sessions, orphaned types. All of that becomes noise in Claude's context window, which means worse generations, which means more manual corrections. I started running Knip weekly to remove unused code and it made a noticeable difference in output quality. The cleaner the codebase, the better Claude performs. Wrote about the specific patterns here: jw.hn/ai-code-hygiene

4

1 more reply

Continue this thread

BC_MARO

1d ago

The context window insight is spot on. I ran into the same thing and started treating each coding phase as its own session with a clean slate. The knowledge flywheel approach is interesting though - automatically extracting and re-injecting learnings is something I have been doing manually with markdown files. Will check out the Go CLI.

2

1 more reply

Continue this thread

BP041

19h ago

100% agree on the context window thing. we serve enterprise clients and the single-session approach was killing us -- agent would nail the architecture discussion, then completely forget it when writing the actual implementation.

switched to splitting sessions by phase (planning → scaffolding → implementation → testing) and our consistency went way up. yeah it's more manual handoff work, but the quality difference is massive.

one pattern that worked: use the first session to generate a detailed spec doc, save it to the repo, then reference it in all subsequent sessions. basically treating the markdown file as shared memory between isolated agent runs.

2

theabominablewonder

18h ago

Yeah the context windows crushed me financially in month 1, but it’s worth learning by doing and seeing how much of an impact these things can have.

2

_Bo_Knows

7h ago

Same. Claude for sure is expensive and forces you to learn fast lol

2

Continue this thread

atomique90

13h ago

Wow. Thanks for the work and also for sharing it. I will having a look into it. Feels like I found good value to learn from this thread and especially the repository. Will definitely try this out.

2

• Promoted

This MCP makes Cursor 70% better

blingblongblah

12h ago

Is there a systematic way of figuring out if your context window is getting too full? Or do you have to judge based on output quality?

2

1 more reply

Continue this thread

[deleted]

1d ago

Comment removed by moderator

8

griwulf

1d ago

Bot. How about you actually pay to advertise your amazing tool instead of astroturfing here?

4

1 more reply

Continue this thread

---

## View Post in

Français

Reddit Rules Privacy Policy User Agreement Your Privacy Choices Accessibility Reddit, Inc. © 2026. All rights reserved.


