# usecases

id: 3d01ae2ffc82
title: Clawdbot/OpenClaw workflows that are actually useful : r/AI_Agents
source_url: https://www.reddit.com/r/AI_Agents/comments/1qsfr58/clawdbotopenclaw_workflows_that_are_actually/
source_platform: reddit
author: unknown
published_at: 2026-01-31T00:00:00+00:00
collected_at: 2026-03-14T01:00:30.385832+00:00
scenario_type: 工作流自动化
novelty: similar
similar_to_ids: ["53435200c5ef", "95b07c16360e", "88a03457f4c8", "9d622833f3fc", "93d2c2bcd5d9"]
summary:
讨论OpenClaw/Clawdbot AI代理的实际应用场景，包括晨间简报、竞争对手监测和个人知识管理。用户反映虽然概念有趣但成本效益比有限，认为现有工具（Perplexity、ChatGPT等）可更廉价地实现相同功能，核心问题是自主代理是否能解决传统工具无法解决的问题。

tools_used:
["OpenClaw", "Clawdbot", "Perplexity", "Gemini", "NotebookLM", "ChatGPT", "Cursor", "Copilot", "n8n"]

raw_content:
Clawdbot/OpenClaw workflows that are actually useful : r/AI_Agents

Clawdbot/OpenClaw workflows that are actually useful : r/AI_Agents Skip to main content Clawdbot/OpenClaw workflows that are actually useful : r/AI_Agents

Go to AI_Agents

r/AI_Agents 1mo ago

huntern_

# Clawdbot/OpenClaw workflows that are actually useful

It seems like everyone these days are either using Openclaw or talking about it. I researched a few genuinely useful use-cases for anyone using Openclaw or thinking about trying it.

Here they are 👇

Morning brief:

Have Openclaw brief you every morning on the things that are important to you. Have it access what you need to get done today, weather, news and trends that you are actually interested in, etc.

Employee for your business:

OpenClaw can check on competitors while you’re asleep and see whats working (or not working) for them. It can also audit and complete annoying tasks that can save you time. Whether thats content repurposing, copy, or building new features.

Second Brain:

One of the more useful things I find for it is acting as your second brain. You can save links, notes, images, etc to your agent which can then build out a place for you to find those items. Or have it resurface useful information when necessary through text.

Hopefully this helped spark some ideas for your own personal agent.

I still think Openclaw has a lot of security risks depending on how you use it but it can definitely be useful.

Read more

Share

---

• Promoted

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

---

anthonyDavidson31

1mo ago

Safety first, so before running Clawdbot (OpenClaw) make sure to check out this post and implement all the precautions to not get hacked:

https://www.reddit.com/r/ArtificialInteligence/comments/1qqja6j/malware_targeting_thousands_of_ai_agent_users_was/

4

anjelina-pit

1mo ago

Completely irrelevant for the topic being discussed here .....

1

RadShad

1mo ago

Found the malware

1

Continue this thread Continue this thread

KingPapaco

1mo ago

I’ve been experimenting with OpenClaw for about a week now, and honestly, I’m struggling to find a 'killer use case' with a positive ROI.

The scenarios you mentioned—morning briefs, competitor research, and second brain—are things I already handle seamlessly using Perplexity, Gemini, NotebookLM, or ChatGPT. In fact, for my specific workflow in web development and AI-assisted coding, OpenAI’s Codex (or even Cursor/Copilot) feels unbeatable in terms of speed and accuracy.

My main concern is the cost-to-value ratio. I’ve already spent $50 in credits this week despite optimizing my flows, and I haven't seen a result that I couldn't have achieved for 1/10th of that price using standard LLMs and n8n automation.

My question for the power users: Is there a workflow where OpenClaw does something structurally different? I’m looking for tasks where the agentic autonomy actually solves a problem that a linear API call or a chat interface can't, rather than just being an 'expensive wrapper' for a reasoning model.

Still searching for that 10x moment. Any thoughts?

4

NoAlbatross1990

22d ago

I think other than accessing CLIs and web browser, it does anything a regular LLM does, which still seems like a ton of potential use cases, but... like, if I have my iPhone, I can just "hey siri, schedule ..."

We can have more complex things like asking it to open a website, and fill a cart full of groceries and give you an overview to confirm that.

1

Continue this thread

huntern_

1mo ago

Get the full breakdown here completely free.

0

AutoModerator

1mo 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

• Promoted

Queue up 5 tasks in Cowork and get back to the work only you can do.

Collapse video player

Ro0tuX

1mo ago

I gutted some features from it for my own local agent, the chat feature to initiate action specifically. Using Signal to "Note to Self" back to my agent for deep research, build out reports is neat.

1

[deleted]

1mo ago

Comment deleted by user

KingPapaco

1mo ago

I don’t agree with that! I wrote him an email and he replied. I think that shows he’s a very dedicated founder.

1

---

## View Post in

हिन्दी

Tiếng Việt

Português (Brasil)

Русский

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

Expand Navigation Collapse Navigation


id: 84c9721be3eb
title: The ULTIMATE OpenClaw Setup Guide! 🦞 : r/aiToolForBusiness
source_url: https://www.reddit.com/r/aiToolForBusiness/comments/1r4uzp4/the_ultimate_openclaw_setup_guide/
source_platform: reddit
author: unknown
published_at: 2026-03-14T01:00:09.282296+00:00
collected_at: 2026-03-14T01:00:44.268669+00:00
scenario_type: 终端与CLI增强
tools_used: ["OpenClaw", "Node.js", "Claude/Anthropic", "WhatsApp", "Telegram", "Discord", "Slack"]
novelty: similar
similar_to_ids: ["0b5c4741d1c1", "faae7106be20", "77b4be38215d"]
summary:
本指南介绍了OpenClaw这一本地AI助手框架的安装配置，允许用户通过多个即时通讯应用与AI交互，并在本地计算机运行以保护隐私。该项目结合了终端工具增强与本地数据处理，为个人用户提供了实用的AI自动化能力，但主要面向技术用户。

raw_content:
The ULTIMATE OpenClaw Setup Guide! 🦞 : r/aiToolForBusiness

The ULTIMATE OpenClaw Setup Guide! 🦞 : r/aiToolForBusiness Skip to main content The ULTIMATE OpenClaw Setup Guide! 🦞 : r/aiToolForBusiness

Go to aiToolForBusiness

r/aiToolForBusiness 3d ago

Sea_Manufacturer6590

# The ULTIMATE OpenClaw Setup Guide! 🦞

r/openclawsetup• 3 days ago

The ULTIMATE OpenClaw Setup Guide! 🦞

## What Even IS OpenClaw??

Okay so like, imagine having your own personal AI assistant that's basically like Jarvis from Iron Man, except it's a LOBSTER. Yeah, you heard that right. A LOBSTER. 🦞

OpenClaw (which used to be called Clawdbot because lobsters have claws, get it?) is this INSANE program that lets you:

- Talk to AI through WhatsApp, Telegram, Discord, Slack, and like a MILLION other apps

- Make it do stuff on your computer like open programs, search the web, and basically anything

- Have it remember stuff about you so it gets smarter over time

- Run it on YOUR computer so your data stays private (not on some weird server somewhere)

It's basically like having a super smart robot friend that lives in your computer and can help you with literally ANYTHING. My mind was BLOWN when I first set this up.

---

## Before We Start - What You Need (The Boring But Important Part)

Okay so before we dive in, you need a few things. Don't worry, I'll explain EVERYTHING:

### 1. A Computer

You need one of these:

- **Mac** (the Apple computer thing)

- **Windows** (the normal PC most people have)

- **Linux** (this is like the super nerdy computer thing but it's actually really cool)

### 2. Node.js (Version 22 or Higher)

Now you're probably like "what the heck is Node.js??" Don't worry, I was confused too!

**What is Node.js?** It's basically a thing that lets your computer run JavaScript programs. JavaScript is a programming language (like how English is a language but for computers). OpenClaw is built with JavaScript, so we need Node.js to make it work.

**How to check if you have it:**

Open your Terminal (on Mac) or Command Prompt (on Windows)

- **Mac**: Press Command + Space, type "Terminal", hit Enter

- **Windows**: Press Windows key, type "cmd", hit Enter

Type this and press Enter: `node --version`

If you see something like `v22.1.0` or any number that starts with 22 or higher, YOU'RE GOOD!

If it says "command not found" or shows a number lower than 22, you need to install it

**How to install Node.js if you don't have it:**

Go to https://nodejs.org

Download the version that says "LTS" (that means Long Term Support, which is the stable one)

Run the installer (just click Next a bunch of times, it's pretty easy)

Check again with `node --version` to make sure it worked

### 3. An AI Service Account

OpenClaw needs to talk to an AI service to actually be smart. You need EITHER:

**Option A: Anthropic (Claude)**

- This is my FAVORITE because Claude is super smart

- You need a Claude account (Pro or Max is better but not required)

- Go to https://www.anthropic.com/

- Sign up and get an API key (I'll show you how later)

**Option B: OpenAI (ChatGPT)**

- This works too and lots of people use it

- You need an OpenAI account

- Go to https://openai.com/

- Sign up and get an API key

**PRO TIP**: Claude Opus 4.5 is REALLY good for this, so if you can afford it, I'd recommend getting Claude Pro or Max!

### 4. About 30 Minutes of Your Time

This setup isn't SUPER fast but it's not hard either. Just follow along step by step!

---

## PART 1: Installing OpenClaw (The Easy Part!)

Alright, let's DO THIS! 🚀

### Step 1: Open Your Terminal/Command Prompt

I already explained how to do this above, but here it is again:

- **Mac**: Command + Space, type "Terminal"

- **Windows**: Windows key, type "cmd" or "PowerShell"

- **Linux**: You probably already know how to do this lol

### Step 2: Install OpenClaw

Now here's where the MAGIC happens. We're gonna use a one-line installer that does EVERYTHING for you!

**For Mac or Linux, type this EXACTLY:**

```bash

curl -fsSL https://openclaw.ai/install.sh| bash

```

**For Windows (use PowerShell), type this:**

```powershell

iwr -useb https://openclaw.ai/install.ps1| iex

```

### What's Happening Here?

Let me break down that weird command because I was SO confused at first:

- `curl -fsSL` = This is a program that downloads stuff from the internet

- ` https://openclaw.ai/install.sh`= This is the website address where the installer lives

- `| bash` = This means "take what we just downloaded and run it"

So basically, we're downloading the installer and running it all in one command. Pretty cool, right?

### Step 3: Wait For It To Install

Now you'll see a BUNCH of text scrolling by. Don't freak out! This is normal. The installer is:

Downloading OpenClaw

Installing all the extra stuff it needs (called "dependencies")

Setting everything up

Maybe installing Node.js if you didn't have it

This takes like 2-5 minutes depending on your internet speed.

### Step 4: Check If It Worked

Once it's done, type this:

```bash

openclaw --version

```

If you see a version number (like `v2025.2.14` or something), IT WORKED! 🎉

If you see "command not found", something went wrong. Try closing your terminal and opening a new one, then try again.

---

## PART 2: The Onboarding Wizard (This Is Where It Gets FUN!)

Okay so now we have OpenClaw installed, but it doesn't know anything about YOU yet or how to connect to AI services. This is where the onboarding wizard comes in!

### Step 1: Start The Wizard

Type this command:

```bash

openclaw onboard --install-daemon

```

**What does --install-daemon mean?**

A "daemon" is basically a program that runs in the background all the time. It's like having OpenClaw always ready to help you, even if you close the terminal!

### Step 2: Follow The Wizard

Now the wizard is going to ask you a BUNCH of questions. I'll go through each one:

#### Question 1: "What should we call your assistant?"

You can name it ANYTHING you want! Some cool ideas:

- Jarvis (like Iron Man)

- Alfred (like Batman)

- Cortana (like Halo)

- Or make up your own! I named mine "Lobster Larry" because I thought it was funny lol

Just type the name and press Enter.

#### Question 2: "Which AI provider do you want to use?"

This is asking which AI service you want to connect to. Use your arrow keys to select either:

- **Anthropic** (if you have Claude)

- **OpenAI** (if you have ChatGPT)

Press Enter when you've selected one.

#### Question 3: "Enter your API key"

Okay so this is SUPER important. An API key is like a secret password that lets OpenClaw talk to the AI service.

**How to get your API key:**

**For Anthropic/Claude:**

Go to https://console.anthropic.com/

Sign in to your account

Click on "API Keys" in the menu

Click "Create Key"

Copy the key (it looks like a bunch of random letters and numbers)

Paste it into the terminal (you won't see it appear but trust me it's there)

Press Enter

**For OpenAI:**

Go to https://platform.openai.com/api-keys

Sign in

Click "Create new secret key"

Copy it and paste it into the terminal

Press Enter

**IMPORTANT**: Keep this key SECRET! Don't share it with anyone or post it online!

#### Question 4: "Which model do you want to use?"

This is asking which specific AI brain you want to use. The wizard will show you options like:

- `claude-opus-4.5` (the REALLY smart one, costs more)

- `claude-sonnet-4.5` (pretty smart, cheaper)

- `gpt-4` (OpenAI's smart one)

- And more...

Use arrow keys to pick one. I recommend Claude Opus 4.5 if you can!

#### Question 5: "Do you want to set up messaging channels?"

This is asking if you want to connect OpenClaw to stuff like WhatsApp, Telegram, Discord, etc.

You can say:

- **Yes** - if you want to chat with it through messaging apps (recommended!)

- **No** - if you just want to use the web interface for now (you can add channels later)

If you say yes, it'll ask you more questions about which channels you want.

#### Question 6: "Which channels do you want to set up?"

If you chose to set up channels, you'll see a list like:

- WhatsApp

- Telegram

- Discord

- Slack

- And more...

Use Space bar to select the ones you want, then press Enter.

**NOTE**: Some channels need extra setup. I'll explain each one in detail later!

#### Question 7: "Do you want to install the gateway daemon?"

Say **YES** to this! The daemon makes OpenClaw run in the background all the time, so it's always ready.

Press Enter and it'll set everything up!

### Step 3: Wait For Setup To Finish

The wizard will now:

Create config files

Set up the gateway (the thing that controls everything)

Start the daemon

Do some final checks

This takes like 30 seconds.

---

## PART 3: Understanding What Just Happened

Okay so before we continue, let me explain what OpenClaw actually created on your computer:

### The OpenClaw Home Folder

OpenClaw created a folder called `.openclaw` in your home directory. The dot at the beginning makes it hidden (sneaky!).

**Where is it?**

- **Mac/Linux**: `/home/yourusername/.openclaw`

- **Windows**: `C:\Users\yourusername\.openclaw`

**What's inside?**

- `openclaw.json` - The config file (all your settings)

- `credentials/` - Your API keys and channel logins

- `workspace/` - Where OpenClaw saves stuff

- `logs/` - Records of what OpenClaw does

### The Gateway

The gateway is like the control center for OpenClaw. It's a program that runs on your computer and manages everything:

- Talking to AI services

- Handling messages from different channels

- Running commands

- Keeping everything organized

It runs on port 18789 (that's like a specific door on your computer).

---

## PART 4: Checking If Everything Works

Let's make sure everything is running properly!

### Step 1: Check Gateway Status

Type this:

```bash

openclaw gateway status

```

You should see something like:

```

✓ Gateway is running

✓ Port: 18789

✓ Status: healthy

```

If it says "not running", type:

```bash

openclaw gateway start

```

### Step 2: Open The Dashboard

This is SO COOL. OpenClaw has a web dashboard you can use! Type:

```bash

openclaw dashboard

```

This will open your web browser and show you the OpenClaw control panel! It looks super professional and you can:

- Chat with your AI directly

- See what it's doing

- Check settings

- View logs

If it doesn't open automatically, go to http://127.0.0.1:18789/ in your browser.

### Step 3: Send Your First Message!

In the dashboard, there should be a chat box. Try typing:

```

Hello! Can you introduce yourself?

```

If the AI responds, **CONGRATULATIONS!!!** You just successfully set up OpenClaw! 🎉🎊🦞

---

## PART 5: Setting Up Messaging Channels (The REALLY Cool Part!)

Okay so now you can chat with OpenClaw through the web dashboard, but the REAL magic is chatting through your regular messaging apps! Here's how to set up each one:

### Setting Up WhatsApp (Super Popular!)

WhatsApp is probably the hardest one to set up but it's SO worth it!

**Step 1: Start the WhatsApp login**

```bash

openclaw channels login whatsapp

```

**Step 2: Scan the QR Code**

A QR code will appear in your terminal! Here's what to do:

Open WhatsApp on your phone

Tap the three dots (menu)

Select "Linked Devices"

Tap "Link a Device"

Point your phone camera at the QR code on your computer screen

Wait for it to connect

**Step 3: Test it!**

Send a message to yourself on WhatsApp (yes, you can message yourself!). Type:

```

Hey! Are you working?

```

OpenClaw should respond! How cool is that?!

**IMPORTANT SAFETY THING**: By default, OpenClaw will ONLY respond to numbers you've approved. This keeps random people from bothering your AI. To approve a number, use:

```bash

openclaw pairing approve whatsapp +15555551234

```

### Setting Up Telegram (The Easiest One!)

Telegram is WAY easier than WhatsApp!

**Step 1: Create a Telegram Bot**

Open Telegram and search for `@BotFather` (it's an official Telegram account)

Start a chat and type `/newbot`

Follow the instructions to name your bot

BotFather will give you a token (a long string of numbers and letters)

COPY THIS TOKEN!

**Step 2: Add the token to OpenClaw**

Open your config file:

```bash

openclaw config edit

```

Find the section that says `channels` and add this:

```json

"telegram": {

"botToken": "paste-your-token-here"

}

```

Save and close the file.

**Step 3: Restart the gateway**

```bash

openclaw gateway restart

```

**Step 4: Test it!**

Open Telegram

Search for your bot (the name you gave it)

Start a chat

Type "Hello!"

Your bot should respond! 🤖

### Setting Up Discord (For Gamers!)

**Step 1: Create a Discord Bot**

Go to https://discord.com/developers/applications

Click "New Application"

Give it a name

Go to "Bot" in the left menu

Click "Add Bot"

Click "Reset Token" and copy the token

Turn on these settings:

- Presence Intent

- Server Members Intent

- Message Content Intent

**Step 2: Add to OpenClaw**

Open config:

```bash

openclaw config edit

```

Add this:

```json

"discord": {

"token": "your-bot-token-here"

}

```

**Step 3: Invite Bot to Your Server**

Go back to the Discord Developer Portal

Click "OAuth2" then "URL Generator"

Check "bot"

Check these permissions:

- Send Messages

- Read Messages

- Read Message History

Copy the generated URL

Paste it in your browser

Select a server and click Authorize

**Step 4: Restart and Test**

```bash

openclaw gateway restart

```

Now go to your Discord server and type a message to your bot!

### Setting Up Other Channels

OpenClaw supports a TON of other channels:

- **Slack**: Similar to Discord but for work

- **Google Chat**: Google's messaging thing

- **Signal**: Super secure messaging

- **iMessage**: Apple's messaging (Mac only)

- **Matrix**: Decentralized messaging

- And more!

Each one has its own setup process. Check the OpenClaw docs for specific instructions!

---

## PART 6: Making OpenClaw REALLY Smart (Skills & Tools)

Okay so now OpenClaw can chat with you, but let's make it SUPER POWERFUL by giving it tools!

### What Are Skills?

Skills are like apps that OpenClaw can use. For example:

- Web browsing skill lets it search the internet

- Calendar skill lets it manage your schedule

- File management skill lets it organize files

- And TONS more!

### How to Add Skills

**Step 1: Browse Available Skills**

Go to https://clawhub.ai to see all available skills! There are hundreds!

**Step 2: Install a Skill**

Let's install the web search skill as an example:

```bash

openclaw skills install web-search

```

**Step 3: Test It**

Now ask OpenClaw:

```

Can you search the internet for information about dinosaurs?

```

It should be able to search and tell you what it finds!

### Cool Skills to Try

Here are some AWESOME skills I recommend:

- `calendar` - Manage your calendar

- `weather` - Get weather updates

- `spotify` - Control Spotify

- `file-organizer` - Auto-organize your files

- `code-helper` - Help with programming

- `homework-helper` - Help with schoolwork (don't just copy though!)

---

## PART 7: Advanced Stuff (For When You Get Comfortable)

### Customizing Your AI's Personality

You can actually change how your AI talks! Cool right?

**Step 1: Find the workspace folder**

```bash

cd ~/.openclaw/workspace

```

**Step 2: Edit the SOUL.md file**

This file controls your AI's personality! Open it:

```bash

nano SOUL.md

```

You can add things like:

```

You are a friendly AI assistant who loves making jokes.

You should always be encouraging and positive.

You really like space facts and bring them up sometimes.

```

Save it (Ctrl+X, then Y, then Enter).

**Step 3: Restart**

```bash

openclaw gateway restart

```

Now your AI will have the personality you described!

### Running OpenClaw 24/7

If you want OpenClaw running ALL THE TIME (even when you restart your computer):

**On Mac/Linux:**

The daemon should already do this, but to make sure:

```bash

openclaw gateway --install-daemon

```

**On Windows:**

You'll need to set up a Windows Service. This is a bit complicated, but the OpenClaw docs have instructions!

### Using Multiple AI Models

You can actually use DIFFERENT AI models for different things!

Edit your config:

```bash

openclaw config edit

```

Add something like:

```json

"models": {

"chat": "claude-opus-4.5",

"quick": "claude-sonnet-4.5",

"cheap": "gpt-3.5-turbo"

}

```

Now you can use the expensive smart model for important stuff and cheaper models for simple tasks!

---

## PART 8: Common Problems (And How to Fix Them!)

### Problem: "Command not found"

**Solution**: The terminal doesn't know where OpenClaw is. Try:

Close terminal and open a new one

Run the installer again

Add OpenClaw to your PATH manually (ask a parent or teacher for help)

### Problem: "Gateway won't start"

**Solution**: Something else might be using port 18789. Try:

```bash

openclaw gateway --port 18790

```

### Problem: "AI isn't responding"

**Solutions**:

Check your API key is correct

Make sure you have credits/subscription with your AI service

Check the logs:

```bash

openclaw logs

```

### Problem: "WhatsApp keeps disconnecting"

**Solution**: WhatsApp is picky about staying connected. Try:

Keeping your phone connected to internet

Not logging out of WhatsApp

Re-scanning the QR code if needed

### Problem: "It's using too much money!"

**Solution**: You can set limits! Edit config:

```json

"limits": {

"maxTokensPerDay": 100000,

"alertWhenOver": 50000

}

```

---

## PART 9: Cool Things You Can Do With OpenClaw

Now that you're all set up, here are some AMAZING things you can try:

### 1. Homework Helper

```

Hey! Can you explain photosynthesis in a way that's easy to understand?

```

### 2. Personal Scheduler

```

Remind me to do my science project tomorrow at 4pm

```

### 3. Code Teacher

```

Can you teach me how to make a simple website with HTML?

```

### 4. Research Assistant

```

I'm writing a report about ancient Egypt. Can you help me find interesting facts?

```

### 5. Creative Writing Partner

```

Help me write a short story about a robot who wants to be a chef

```

### 6. Math Tutor

```

Can you explain how to solve quadratic equations step by step?

```

### 7. Language Practice

```

Can we practice Spanish? Let's have a conversation about food.

```

### 8. Fun Conversations

```

If you could be any animal besides a lobster, what would you be and why?

```

---

## PART 10: Staying Safe Online

Since OpenClaw connects to the internet and messaging apps, here are some IMPORTANT safety rules:

### 1. NEVER Share Your API Keys

Your API key is like a password. Don't:

- Post it on social media

- Share it with friends

- Put it in public code

### 2. Be Careful With Personal Information

Don't tell OpenClaw:

- Your home address

- Your phone number

- Your parents' credit card info

- Passwords to other accounts

### 3. Use The Pairing System

OpenClaw has a "pairing" feature that makes sure only approved people can talk to your AI. Keep it turned on!

### 5. Don't Rely On It For Everything

OpenClaw is SUPER smart but it can still make mistakes! Always:

- Double-check important information

- Don't use it to cheat on homework (use it to LEARN instead!)

- Think critically about what it tells you

---

## PART 11: Next Steps & Resources

### Where to Learn More

- **Official Docs**: https://docs.openclaw.ai(super detailed!)

- **GitHub**: https://github.com/openclaw/openclaw(see the code!)

- **ClawHub**: https://clawhub.ai(find cool skills!)

### Ideas for Advanced Projects

Once you're comfortable, try:

**Build your own skill** - Make OpenClaw do something unique!

**Set up automation** - Have it do tasks automatically

**Create a multi-agent system** - Multiple AI assistants working together!

**Integrate with smart home** - Control lights, music, etc.

### Keep Learning!

Technology is CONSTANTLY changing! Stay curious and keep experimenting. The more you play with OpenClaw, the more you will learn and grow

68 upvotes 13 comments

Share

---

• Promoted

Build your online store and start selling today. No tech skills needed.

Collapse video player

---

AccomplishedArt1791

2d ago

Very detailed guide, thanks for sharing. I don't have an extra machine, what's your view point on installing this on my main machine, specially about privacy and safety concerns (for people who can't code)

1

Sea_Manufacturer6590

2d ago

I honestly would not do that even if u can find an old phone or laptop you definitely want to put it on a factory restored machine as nd gradually give it more and more freedom as you and it learn you will make mistakes I'm sure but the plan is to minimize and proper planning for these.

1

AccomplishedArt1791

2d ago

Got it

1

Continue this thread Continue this thread

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


id: f2f51ffcd2a1
title: What Real Use Cases Would People Want From OpenClaw? - Reddit
source_url: https://www.reddit.com/r/AgentsOfAI/comments/1rao3z6/what_real_use_cases_would_people_want_from/
source_platform: reddit
author: unknown
published_at: 2026-02-21T00:00:00+00:00
collected_at: 2026-03-14T01:00:57.889001+00:00
scenario_type: 工作流自动化
novelty: similar
similar_to_ids: ["3d01ae2ffc82", "b2c80ce8e19d", "88a03457f4c8", "95b07c16360e"]
summary:
这是关于OpenClaw AI代理框架实际应用场景的讨论，用户期望它自动化跨应用的重复工作流，如邮件数据导入、日程安排、文件组织和表单填充等。该框架具有较高的实用价值，但需要解决安全性和信任问题才能获得广泛采用。

tools_used:
["OpenClaw", "SAP", "Salesforce", "Dynamics365", "Excel", "Workday", "Email", "Calendar", "File Management Systems"]

raw_content:
What Real Use Cases Would People Want From OpenClaw? - Reddit

What Real Use Cases Would People Want From OpenClaw? : r/AgentsOfAI Skip to main content What Real Use Cases Would People Want From OpenClaw? : r/AgentsOfAI

Go to AgentsOfAI

r/AgentsOfAI 20d ago

Ok-Breakfast-4676

# What Real Use Cases Would People Want From OpenClaw?

OpenClaw is an AI agent framework that can actually take actions across apps. I’m trying to understand what real-world tasks people would want an agent like this to handle. What are the workflows or automations that would make someone set it up and rely on it daily? Looking for all practical use cases people would expect an AI agent to execute across personal life, work, and productivity.

Read more

Share

---

• Promoted

K:AI Marketing Agent plans and launches on-brand campaigns, flows, and forms— no prompts required. Start fast. Grow faster.

---

AutoModerator

20d ago

Moderator Announcement Read More »

Thank you for your submission! To keep our community healthy, please ensure you've followed our rules.

New to the sub? Check out our Wiki(We are actively adding resources!).

Join the Discord: Click here to join our Discord

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

buildingthevoid

20d ago

Biggest value would be automating repetitive, cross-app workflows like scheduling, reporting, and follow-ups so people can stop context switching and save real time daily

3

FormalAd7367

18d ago

could you give some examples?

1

Continue this thread

t0m4t0z

20d ago

For daily use, I'd want it to handle tedious cross-app stuff like pulling data from emails into spreadsheets, scheduling meetings by checking everyone's calendar availability, or automatically organizing downloaded files into the right folders. Basically anything that requires jumping between apps and copying/pasting. What are you building?

2

epSos-DE

20d ago

all that could be just data transfer and data encoder apps.

you need custom apps. Not an AI agent !

3

Continue this thread

CommunicationOld8587

20d ago

SAP, Salesforce, Dynamics365, Excel, Workday, those annoying mandatory security training questionnaires! 😂

2

ah-cho_Cthulhu

20d ago

That’s for posting. I stood up an instance last night and was like.. what do I do with this? I don’t have these problems at the moment. I thought I was missing something, but sounds like I wasn’t.

2

Operation_Fluffy

20d ago

Me too. Set it up. Didn’t trust external plugins without checking the source first. Chatted for a sec. Shrugged and moved on. Uninstalled.

3

Continue this thread

• Promoted

Sound smooth, natural, and unmistakably you, whether you’re drafting a data-heavy proposal or a high-stakes hello.

tleyden

20d ago

It would be amazing if it could fill out forms for me based on a securely stored vault of my personal details.

A bit scary, but maybe if there is "human-in-the-loop" MFA approval on a per field basis, it gets less scary.

2

tleyden

20d ago

Use its memories of the user to recommend discussions of interest. It could work across Reddit, Discord, and other online forums.

2

muthukrishnan749

20d ago

Right now its flexing.

2

friedtensor

20d ago

i mean there are so many. i use it to update my website. built a custom skill that uses strapi's api (headless cms) to update content. i just ask my agent to update and it does it for me, its honestly great, i hated the strapi ui. it pulls insights from multiple newsletters and curates the highlights for me in a daily morning brief. every evening it pulls my google analytics data and shares the key metrics. its creating and updating people in twenty crm for me. i mainly use it to avoid dealing with uis whenever i can

1

RealLordDevien

19d ago

The awesome thing about openclaw is that it can adapt itself to any usecase without needing a programmer to write a workflow or mcp server

1

uriwa

19d ago

The "fill out forms" and "cross-app scheduling" answers are correct but they're also the stuff that breaks trust the fastest. An agent that fills out a form wrong once and you never use it again.

The use cases that actually stick are the ones where the user doesn't care about the exact output, just the gist. Summarize my Slack threads from today. Pull interesting HN/Reddit discussions about X. Draft a weekly update from my git commits. Those are tasks where 80% accuracy is fine and the user reviews before acting. The moment you give an agent unsupervised write access to anything important, adoption drops to zero.

1

jannemansonh

18d ago

one category i'd add: rag-native automation for when workflows need to actually understand documents... moved doc workflows to needle app since you just describe what you want and it builds it. way easier than configuring nodes, especially if you're not super technical

1

• Promoted

Yes, this is what people REALLY say about Capsule CRM. Am I blushing? A little. 😳

zenware

18d ago

What use cases do people find the most value from executive / virtual assistants?

1

CASBooster

16d ago

I started using OpenClaw for emails, quick research and finance news every morning for the novelty of it but it got expensive real quick so I shut it down. I am trying clawpane.co now and so far it's working out ok and costs have been way down.

1

nitix007

16d ago

i personally use it for automotive tasks: one example my bank sends the credit card statement monthly, and I setup a cron that checks everyday if that statement has arrived, calculate how much do I need to pay to prevent incurring interest, add it to google task and remind me a day before and on due date.

1

LockOk8197

12d ago

I use it for content creation, requirement analysis, and SaaS project development

1

One-Project-2966

8d ago

Lack of real use cases is the main issue. but then youtubers came "omg guys look, it opened chrome, I can’t believe it!!"

1

Ok-Breakfast-4676

8d ago

🤣🤣

2

Continue this thread

Forsaken-Kale-3175

7d ago

For more real-world OpenClaw use cases, check out our dedicated subreddit at r/OpenClawUseCases

1

pittburgh_zero

20d ago

Dear lord - I use a claw for EVERYTHING. There’s nothing it can’t do.

-5

James-the-greatest

20d ago

Bullshit answer

4

6 more replies

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.

Expand Navigation Collapse Navigation


id: a34e783b92e8
title: Show HN: Understudy – Teach a desktop agent by demonstrating a task once
source_url: https://github.com/understudy-ai/understudy
source_platform: hackernews
author: bayes-song
published_at: 2026-03-12T17:04:35+00:00
collected_at: 2026-03-14T01:01:08.229593+00:00
scenario_type: 工作流自动化
novelty: similar
similar_to_ids: ["76a435bcb8ee", "f2f51ffcd2a1", "bea33498d6bd", "9d622833f3fc", "6885ba6c5ca2"]
summary:
Understudy是一个本地优先的桌面智能体运行时，通过一次演示教学来自动化跨应用工作流，支持GUI应用、浏览器、终端和消息工具的集成操作。该方案通过记录屏幕视频和语义事件提取任务意图而非坐标，生成可复用且不易损坏的自动化技能，特别适合跨越多个应用的复杂桌面工作流。

tools_used:
["Understudy", "macOS GUI", "Browser", "Shell", "Pixelmator Pro", "Telegram", "Screen recording", "Computer vision"]

raw_content:
Show HN: Understudy – Teach a desktop agent by demonstrating a task once

I built Understudy because a lot of real work still spans native desktop apps, browser tabs, terminals, and chat tools. Most current agents live in only one of those surfaces.<p>Understudy is a local-first desktop agent runtime that can operate GUI apps, browsers, shell tools, files, and messaging in one session. The part I&#x27;m most interested in feedback on is teach-by-demonstration: you do a task once, the agent records screen video + semantic events, extracts the intent rather than coordinates, and turns it into a reusable skill.<p>Demo video: <a href="https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=3d5cRGnlb_0" rel="nofollow">https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=3d5cRGnlb_0</a><p>In the demo I teach it: Google Image search -&gt; download a photo -&gt; remove background in Pixelmator Pro -&gt; export -&gt; send via Telegram. Then I ask it to do the same for Elon Musk. The replay isn&#x27;t a brittle macro: the published skill stores intent steps, route options, and GUI hints only as a fallback. In this example it can also prefer faster routes when they are available instead of repeating every GUI step.<p>Current state: macOS only. Layers 1-2 are working today; Layers 3-4 are partial and still early.<p><pre><code>    npm install -g @understudy-ai&#x2F;understudy
    understudy wizard
</code></pre>
GitHub: <a href="https:&#x2F;&#x2F;github.com&#x2F;understudy-ai&#x2F;understudy" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;understudy-ai&#x2F;understudy</a><p>Happy to answer questions about the architecture, teach-by-demonstration, or the limits of the current implementation.


id: da6cd49c549c
source_platform: reddit
author: unknown
published_at: 2026-03-14T01:00:09.282314+00:00
collected_at: 2026-03-14T01:01:32.244504+00:00
scenario_type: 工作流自动化
tools_used: ["OpenClaw", "GLM-5", "MiniMax M2.5", "WhatsApp", "Telegram", "Discord", "Slack", "Signal", "IRC"]
novelty: repeat
similar_to_ids: ["f2f51ffcd2a1", "b2c80ce8e19d", "88a03457f4c8", "9d622833f3fc"]
title:
OpenClaw's New Update: Your Personal AI Just Got Smarter, Safer, and More Reliable! : r/OpenClawCentral

summary:
OpenClaw是一款开源本地AI助手，支持邮件管理、会议调度和智能家居控制等任务自动化，最新版本2026.2.12增加了GLM-5和MiniMax M2.5模型支持，提升了AI能力和安全性。该工具通过多个即时通讯平台集成实现工作流自动化，具有较高的隐私保护和本地部署价值。

source_url:
https://www.reddit.com/r/OpenClawCentral/comments/1r3da8g/openclaws_new_update_your_personal_ai_just_got/

raw_content:
OpenClaw's New Update: Your Personal AI Just Got Smarter, Safer, and More Reliable! : r/OpenClawCentral

OpenClaw's New Update: Your Personal AI Just Got Smarter, Safer, and More Reliable! : r/OpenClawCentral Skip to main content OpenClaw's New Update: Your Personal AI Just Got Smarter, Safer, and More Reliable! : r/OpenClawCentral

Go to OpenClawCentral

r/OpenClawCentral 2d ago

bruckout

# OpenClaw's New Update: Your Personal AI Just Got Smarter, Safer, and More Reliable!

If you're into AI tools that actually do stuff for you—like managing emails, scheduling meetings, or even controlling smart home devices—all from your favorite chat apps (think WhatsApp, Telegram, or Discord), then OpenClaw is worth checking out. It's an open-source AI assistant that runs right on your computer, keeping your data private and under your control. No cloud subscriptions needed—just plug in your preferred AI brain and let it handle the busywork.

The latest version (2026.2.12) just dropped, and it's a solid upgrade focused on making things easier, faster, and more secure. Here's the quick scoop on what's changing and why it matters for everyday users like us.

What's Changing?

Smarter AI Brains Inside: They've added support for two cutting-edge AI models—GLM-5 and MiniMax M2.5. GLM-5 is like a super-reliable thinker that's great at complex tasks and coding, with way fewer "made-up" answers (hallucinations). MiniMax M2.5 is lightning-fast and excels at breaking down big jobs into steps, like automating workflows or searching the web efficiently.

Old-School Chat Support: Now it works with IRC channels—the classic internet chat system that's still alive in tech communities. Your AI bot can hang out there like one of the regulars.

Major Security Boost: Over 40 fixes to plug holes that could let bad actors sneak in. This includes better protection against fake requests, safer handling of plugins, and treating web content as "untrusted" by default to avoid tricks. Easier Custom Setup and Tweaks: Simpler ways to add your own AI providers or compact data (like cleaning up old chats without losing key info). Plus, improvements to scheduling (cron jobs) so automated tasks don't overlap or fail.

Chat App Upgrades: Better formatting for WhatsApp (bold text, strikethroughs), proper quotes in Telegram, and fixes for Discord, Slack, and Signal to make messages smoother and more reliable. There's one potential gotcha: Some advanced plugin setups might need a quick config tweak for security reasons, but it's straightforward.

The Big Benefits

More Productive and Reliable: With the new models, your AI handles tough tasks quicker—like planning a full project or debugging issues—without forgetting details after a cleanup. Scheduling is now bulletproof, so reminders or automations fire off without hiccups.

Safer for Daily Use: In a world full of hacks, these security updates mean less worry about data leaks or unauthorized access. It's like adding locks to your digital doors while keeping the AI helpful.

Cheaper and Faster Overall: MiniMax M2.5 is designed to be super affordable (pennies per use) and speedy, making OpenClaw feel more like a tireless helper than a slow bot. GLM-5 adds accuracy, so you get better results on the first try. If you're already using OpenClaw, upgrading is easy (just run a quick command).

Newbies: Head to their GitHub for the free download—it's beginner-friendly on Mac, Windows, or Linux.

What do you think? Anyone tried the new version yet? Share your wins (or woes) below—I'm curious how it's working for real-life stuff like home automation or email overload! 🦞

Read more

Share

---

• Promoted

Upload a photo and try before you trim with image generation on ChatGPT.

---

BashX82

1d ago

What's the feedback on these new models?

1

bruckout

1d ago

Lots of positive sentiment from users on Twitter in the last 24 hours. Personally I'd recommend sticking with grok 4.1 thinking/fast . Ita cheaper and arguably better

1

Continue this thread

Cocoa_Linguine

1d ago

How you do even update? 🤓

1

bruckout

1d ago

Tell openclaw to update itself. an update just came out

1

Continue this thread

AvelinoManteigas

1d ago

v2026.2.13 is already out

https://github.com/openclaw/openclaw/releases/tag/v2026.2.13

AI Summary

```

✨ New Features
• Discord Voice Notes: Your bot can now send voice messages using audio files you have on your computer.
• Custom Bot Status: You can now change what the bot is "doing" on Discord (e.g., "Playing OpenClaw" or "Watching the server").
• Images in Web Chat: Fixed a bug where images wouldn't show up in the web chat interface. They should display correctly now.
• Better Filenames: When the bot sends you a document on WhatsApp, it will keep the actual filename instead of just calling everything "file."

🚀 Reliability
• No More Lost Messages: If the OpenClaw system restarts while it’s trying to send a message, it now remembers that message and sends it once it's back online.
• Smarter Replies: The bot is now much better at understanding threads. If you reply to it in a specific thread (on Slack or Discord), it will reply back in that same thread instead of getting confused or starting a new conversation.
• Fewer Crashes: A huge number of background fixes were made to stop the system from freezing up or acting like a "zombie" (running but not doing anything).

🔗 Connecting to Apps
• Telegram Menus: Fixed an issue where having too many commands would break the bot's menu.
• Microsoft Teams: The bot is now better at understanding when you tag it (@mention) in Teams.
• New AI Brains: It is now much easier to connect "Hugging Face" (a popular place for AI models) to OpenClaw if you want to try different AI brains.

🛡️ Security
• Safer Links: The bot is smarter about checking links before it opens them, preventing it from accessing internal network stuff it shouldn't.
• Password Protection: Fixed a setting that could have accidentally saved your secret passwords (environment variables) into plain text files.
• File Permissions: Stricter rules were added to make sure only the system can read your WhatsApp login files.

🛠️ Setup
• Simple Updates: If you use the command line tool to update or install, it won't get stuck or freeze your terminal anymore.
• Mac & Linux: Better support for running the bot on Apple Silicon Macs and different types of Linux servers.
```

edit: summary

2

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


id: 74a0d1b68f38
title: Launch HN: Spine Swarm (YC S23) – AI agents that collaborate on a visual canvas
source_url: https://www.getspine.ai/
source_platform: hackernews
author: a24venka
published_at: 2026-03-13T13:22:40+00:00
collected_at: 2026-03-14T01:01:44.113793+00:00
scenario_type: 工作流自动化
novelty: similar
similar_to_ids: ["220851dd1119", "51d6155061d6", "97dcab4759c8", "5471379ee4ff"]
summary:
Spine Swarm是一个多智能体系统，在无限视觉画布上通过可视化块连接来自动化复杂的非编码工作流，如竞争分析、财务建模和演示文稿生成。该平台支持多个AI模型协作，用户可以显式控制工作流结构，避免了传统聊天界面的线性限制。相比于ChatGPT等聊天工具，它为复杂项目提供了更好的工作区抽象和上下文管理能力。

tools_used:
["Claude", "OpenAI", "Nano Banana Pro", "web browsing", "image generation", "spreadsheets", "slides"]

raw_content:
Launch HN: Spine Swarm (YC S23) – AI agents that collaborate on a visual canvas

Hey HN! We&#x27;re Ashwin and Akshay from Spine AI (<a href="https:&#x2F;&#x2F;www.getspine.ai">https:&#x2F;&#x2F;www.getspine.ai</a>). Spine Swarm is a multi-agent system that works on an infinite visual canvas to complete complex non-coding projects: competitive analysis, financial modeling, SEO audits, pitch decks, interactive prototypes, and more. Here&#x27;s a video of it in action: <a href="https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=R_2-ggpZz0Q" rel="nofollow">https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=R_2-ggpZz0Q</a>.<p>We&#x27;ve been friends for over 13 years. We took our first ML course together at NTU, in a part of campus called North Spine, which is where the name comes from. We went through YC in S23 and have spent about 3 years building Spine across many product iterations.<p>The core idea: chat is the wrong interface for complex AI work. It&#x27;s a linear thread, and real projects aren&#x27;t linear. Sure, you can ask a chatbot to reference the financial model from earlier in the thread, or run research and market sizing together, but you&#x27;re trusting the model to juggle that context implicitly. There&#x27;s no way to see how it&#x27;s connecting the pieces, no way to correct one step without rerunning everything, and no way to branch off and explore two strategies side by side. ChatGPT was a demo that blew up, and chat stuck around as the default interface, not because it&#x27;s the right abstraction. We thought humans and agents needed a real workspace where the structure of the work is explicit and user-controllable, not hidden inside a context window.<p>So we built an infinite visual canvas where you think in blocks instead of threads. Each block is our abstraction on top of AI models. There are dedicated block types for LLM calls, image generation, web browsing, apps, slides, spreadsheets, and more. Think of them as Lego bricks for AI workflows: each one does something specific, but they can be snapped together and composed in many different ways. You can connect any block to any other block, and that connection guarantees the passing of context regardless of block type. The whole system is model-agnostic, so in a single workflow you can go from an OpenAI LLM call, to an image generation mode like Nano Banana Pro, to Claude generating an interactive app, each block using whatever model fits best. Multiple blocks can fan out from the same input, analyzing it in different ways with different models, then feed their outputs into a downstream block that synthesizes the results.<p>The first version of the canvas was fully manual. Users entered prompts, chose models, ran blocks, and made connections themselves. It clicked with founders and product managers because they could branch in different directions from the same starting point: take a product idea and generate a prototype in one branch, a PRD in another, a competitive critique in a third, and a pitch deck in a fourth, all sharing the same upstream context. But new users didn&#x27;t want to learn the interface. They kept asking us to build a chat layer that would generate and connect blocks on their behalf, to replicate the way we were using the tool. So we built that, and in doing so discovered something we didn&#x27;t expect: the agents were capable of running autonomously for hours, producing complete deliverables. It turned out agents could run longer and keep their context windows clean by delegating work to blocks and storing intermediary context on the canvas, rather than holding everything in a single context window.<p>Here&#x27;s how it works now. When you submit a task, a central orchestrator decomposes it into subtasks and delegates each to specialized persona agents. These agents operate on the canvas blocks and can override default settings, primarily the model and prompt, to fit each subtask. Agents pick the best model for each block and sometimes run the same block with multiple models to compare and synthesize outputs. Multiple agents work in parallel when their subtasks don&#x27;t have dependencies, and downstream agents automatically receive context from upstream work. The user doesn&#x27;t configure any of this. You can also dispatch multiple tasks at once and the system will queue dependent ones or start independent ones immediately.<p>Agents aren&#x27;t fully autonomous by default. Any agent can pause execution and ask the user for clarification or feedback before continuing, which keeps the human in the loop where it matters. And once agents have produced output, you can select a subset of blocks on the canvas and iterate on them through the chat without rerunning the entire workflow.<p>The canvas gives agents something that filesystems and message-passing don&#x27;t: a persistent, structured representation of the entire project that any agent can read and contribute to at any point. In typical multi-agent systems, context degrades as it passes between agents. The canvas addresses this because agents store intermediary results in blocks rather than trying to hold everything in memory, and they leave explicit structured handoffs designed to be consumed efficiently by the next agent in the chain. Every step is also fully auditable, so you can trace exactly how each agent arrived at its conclusions.<p>We ran benchmarks to validate what we were seeing. On Google DeepMind&#x27;s DeepSearchQA, which is 900 questions spanning 17 fields, each structured as a causal chain where each step depends on completing the previous one, Spine Swarm scored 87.6% on the full dataset with zero human intervention. For the benchmark we used a subset of block types relevant to the questions (LLM calls, web browsing, table) and removed irrelevant ones like document, spreadsheet, and slide generation. We also disabled human clarification so agents ran fully independently. The agents were not just auditable but also state of the art. The auditability also exposed actual errors in an older benchmark (GAIA Level 3), cases where the expected answer was wrong or ambiguous, which you&#x27;d never catch with a black-box pipeline. We detail the methodology, architecture, and benchmark errors in the full writeup: <a href="https:&#x2F;&#x2F;blog.getspine.ai&#x2F;spine-swarm-hits-1-on-gaia-level-3-and-google-deepmind-deepsearchqa">https:&#x2F;&#x2F;blog.getspine.ai&#x2F;spine-swarm-hits-1-on-gaia-level-3-...</a><p>Benchmarks measure accuracy on closed-ended questions. Turns out the same architecture also leads to better open-ended outputs like decks, reports, and prototypes with minimal supervision. We&#x27;ve seen early users split into two camps: some watch the agents work and jump in to redirect mid-flow, others queue a task and come back to a finished deliverable. Both work because the canvas preserves the full chain of work, so you can audit or intervene whenever you want.<p>A good first task to try: give it your website URL and ask for a full SEO analysis, competitive landscape, and a prioritized growth roadmap with a slide deck. You&#x27;ll see multiple agents spin up on the canvas simultaneously. People have also used it for fundraising pitch decks with financial models, prototyping features from screenshots and PRDs, competitive analysis reports and deep-dive learning plans that research a topic from multiple angles and produce structured material you can explore further.<p>Pricing is usage-based credits tied to block usage and the underlying models used. Agents tend to use more credits than manual workflows because they&#x27;re tuned to get you the best possible outcome, which means they pick the best blocks and do more work. Details here: <a href="https:&#x2F;&#x2F;www.getspine.ai&#x2F;pricing">https:&#x2F;&#x2F;www.getspine.ai&#x2F;pricing</a>. There&#x27;s a free tier, and one honest caveat: we sized it to let you try a real task, but tasks vary in complexity. If you run out before you&#x27;ve had a proper chance to explore, email us at founders@getspine.ai and we&#x27;ll work with you.<p>We&#x27;d love your feedback on the experience: what worked, what didn&#x27;t, and where it fell short. We&#x27;re also curious how others here approach complex, multi-step AI work beyond coding. What tools are you using, and what breaks first? We&#x27;ll be in the comments all day.


id: 066cf297b71a
source_platform: reddit
author: t2_1a3ok8jb
published_at: 2026-03-14T01:00:09.282330+00:00
collected_at: 2026-03-14T01:02:12.181437+00:00
scenario_type: 工作流自动化
tools_used: ["OpenClaw Mission Control System", "Kanban board", "Skill Marketplace"]
novelty: similar
similar_to_ids: ["74a0d1b68f38", "da6cd49c549c", "220851dd1119", "4188cb874081", "6fe122c430d7"]
title:
https://www.reddit.com/r/AISEOInsider/comments/1rb0vb5/openclaw_mission_control_system_clearer_workflows.json?tl=fr

summary:
OpenClaw Mission Control System为用户提供了一个结构化的可视化仪表板来管理复杂的AI代理自动化,通过Kanban看板和技能市场简化了工作流程的组织和扩展。该系统通过集中控制和实时可视化提高了自动化流程的透明度和可管理性,特别适合需要并行运行多个工作流的场景。

source_url:
https://www.reddit.com/r/AISEOInsider/comments/1rb0vb5/openclaw_mission_control_system_clearer_workflows.json?tl=fr

raw_content:
https://www.reddit.com/r/AISEOInsider/comments/1rb0vb5/openclaw_mission_control_system_clearer_workflows.json?tl=fr

OpenClaw Mission Control System gives everyday users a simple way to manage complex automation without getting buried in chaotic chat threads or invisible background processes. 
 
Everything becomes easier to understand because agents operate inside a structured visual dashboard instead of scattered messages. 
 
Anyone can now run multiple workflows in parallel with full visibility and control.

Watch the video below:

https://www.youtube.com/watch?v=GpQcz\_eKiNo

Want to make money and save time with AI? Get AI Coaching, Support &amp; Courses 
👉 https://www.skool.com/ai-profit-lab-7462/about

# Mission Control Elevates the OpenClaw Mission Control System Into a Real Orchestration Layer

The OpenClaw Mission Control System introduces a central layer that sits above your agents and organizes everything they do.

Instead of managing dozens of scattered prompts, you now lead automation from one consolidated screen.

This orchestration layer acts like an air-traffic control system for tasks, giving you an overview of what is happening and where your agents need direction.

People feel more confident because the system shows every active process without requiring users to chase updates.

The OpenClaw Mission Control System transforms automation from reactive back-and-forth messaging into coordinated, predictable execution.

Users finally get the clarity needed to run more ambitious workflows without confusion or risk.

# Visual Boards Bring Structure to the OpenClaw Mission Control System

Mission Control uses a Kanban structure that instantly improves how people track progress.

Each task moves through a defined path: Backlog, In Progress, Review, and Done.

This structure eliminates the messy guessing game of wondering which agent handled what.

Users see the actual flow of work the moment it happens because the board updates in real time.

Clarity replaces uncertainty.

Momentum becomes visible instead of buried inside chat logs.

The OpenClaw Mission Control System becomes easier to trust because you always know where each workflow stands.

This structure feels natural to beginners and powerful to advanced users, making it a universal layout for automation.

# Skill Marketplace Expands the OpenClaw Mission Control System Automatically

The Skill Marketplace makes upgrading automation simple.

Users install new abilities the same way they install apps on a phone.

Skills extend what agents can do without any code, configuration, or setup complexity.

Capabilities grow with each addition because the marketplace introduces everything from writing tools to productivity modules to specialized automation skills.

This modular growth means people never outgrow the system.

Whether you are new to automation or already running large workflows, the OpenClaw Mission Control System keeps expanding with you.

The marketplace removes friction and gives anyone the power to build more advanced systems instantly.

# Board Groups Help the OpenClaw Mission Control System Scale Without Chaos

As workflows grow, organizing them becomes critical.

Board groups solve this by clustering multiple boards into neat collections.

You might separate personal tasks, client tasks, internal operations, and content processes into different groups.

This structure keeps the dashboard clean even when the automation system becomes large.

Users stop feeling overwhelmed because navigation becomes straightforward and intuitive.

Board groups preserve clarity at scale, making the OpenClaw Mission Control System feel manageable even when dozens of workflows run at once.

As you expand your automation, this becomes one of the most powerful tools for staying organized.

# Approval Flows Strengthen the OpenClaw Mission Control System

Mission Control lets users add human approval steps wherever they want more oversight.

This ensures that sensitive actions never run without review.

Users can require confirmation before agents publish posts, send emails, modify files, or interact with external tools.

These checkpoints create a safer automation system that protects users from unintended actions.

Approval flows align automation with human decision-making instead of removing people from the process.

This reinforces trust and gives the OpenClaw Mission Control System the reliability users need for long-term workflows.

Automation becomes more confident because you control the moments that matter most.

# Gateway Support Turns the OpenClaw Mission Control System Into a Distributed Network

Mission Control supports multiple gateways, allowing automation to run across different computers, servers, and environments.

A laptop gateway can handle lightweight tasks.

A cloud gateway can handle heavier workloads.

A dedicated server gateway can manage scheduled or persistent operations.

Everything appears inside Mission Control with seamless coordination.

Users gain the power to run distributed systems without needing advanced technical setups.

Scaling becomes natural because each gateway adds more capacity.

The OpenClaw Mission Control System becomes a networked automation engine rather than a single-device tool.

This distributed capability gives individuals and teams far more flexibility in how they design workflows.

# Real-Time Activity View Gives the OpenClaw Mission Control System Full Transparency

Mission Control includes a live activity feed that shows every action happening inside OpenClaw.

You watch tasks start, progress, complete, pause, or fail the moment they occur.

This transparency eliminates uncertainty because everything is visible.

Troubleshooting becomes easier since errors show up immediately instead of hours later.

Users learn more about how their system behaves by observing the workflow in real time.

This visibility makes the OpenClaw Mission Control System feel alive, dynamic, and responsive.

People understand their automation better because they see its activity unfold instead of staying hidden beneath the surface.

# Custom Dashboards Give the OpenClaw Mission Control System Unlimited Flexibility

Mission Control supports fully customizable dashboards built using natural language instructions.

Users describe layouts, components, colors, and widgets, and OpenClaw generates the dashboard automatically.

This makes personal customization accessible even to people with no coding background.

A basic version can be created in minutes, and iterative improvements shape it into a polished, personalized system.

Dashboards can include project views, productivity widgets, agent summaries, content pipelines, or anything the user imagines.

This flexibility means no one is limited to a fixed interface.

The OpenClaw Mission Control System becomes adaptable to every user's workflow style, whether simple or incredibly complex.

# Mission Control Turns Automation Into Strategic Leverage

Mission Control changes how people think about automation.

Tasks no longer feel like discrete, unrelated outputs.

Instead, they become parts of a coordinated system that follows clear logic and produces consistent results.

Users stop micromanaging instructions and start building repeatable, reliable processes.

This shift frees time, reduces friction, and increases output.

Automation becomes more of a strategic advantage than a simple convenience.

The OpenClaw Mission Control System gives people a predictable, organized, and scalable foundation for running their digital operations.

It becomes the engine behind more productive days, clearer planning, and more ambitious goals.

# 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 people 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 OpenClaw Mission Control System

1. What makes the OpenClaw Mission Control System effective for beginners? It provides visual structure, simple navigation, and clear workflows that make automation easier to manage.
2. Does Mission Control help with large automation systems? Yes. Board groups, gateways, and live activity views make it scalable without losing clarity.
3. Can the Skill Marketplace replace coding? In most cases, yes. Users install new abilities instantly without writing any technical instructions.
4. Is Mission Control safe to use for sensitive tasks? Yes. Approval flows ensure humans review important actions before they execute.
5. Why is Mission Control becoming essential for OpenClaw users? It turns scattered automation into a unified system, making work faster, clearer, and more reliable.


id: 4c49a6a48725
title: Show HN: Context Gateway – Compress agent context before it hits the LLM
source_url: https://github.com/Compresr-ai/Context-Gateway
source_platform: hackernews
author: ivzak
published_at: 2026-03-13T17:58:22+00:00
collected_at: 2026-03-14T01:02:22.372170+00:00
scenario_type: 终端与CLI增强
novelty: similar
similar_to_ids: ["abb1b9505bb9", "853c63f738f0", "257ed0953657"]
summary:
Context Gateway是一个开源代理工具，通过压缩代理的上下文输出来优化LLM的效率，解决了AI代理在管理大量工具输出时的噪声问题。该方案使用小型语言模型智能压缩工具返回的内容，同时提供成本控制、会话追踪和扩展机制，显著提升了代理的性能和成本效益。

tools_used:
["Context Gateway (proxy)", "Claude Code", "OpenClaw", "Small Language Models (SLMs)", "grep", "Slack"]

raw_content:
Show HN: Context Gateway – Compress agent context before it hits the LLM

We built an open-source proxy that sits between coding agents (Claude Code, OpenClaw, etc.) and the LLM, compressing tool outputs before they enter the context window.<p>Demo: <a href="https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=-vFZ6MPrwjw#t=9s" rel="nofollow">https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=-vFZ6MPrwjw#t=9s</a>.<p>Motivation: Agents are terrible at managing context. A single file read or grep can dump thousands of tokens into the window, most of it noise. This isn&#x27;t just expensive — it actively degrades quality. Long-context benchmarks consistently show steep accuracy drops as context grows (OpenAI&#x27;s GPT-5.4 eval goes from 97.2% at 32k to 36.6% at 1M <a href="https:&#x2F;&#x2F;openai.com&#x2F;index&#x2F;introducing-gpt-5-4&#x2F;" rel="nofollow">https:&#x2F;&#x2F;openai.com&#x2F;index&#x2F;introducing-gpt-5-4&#x2F;</a>).<p>Our solution uses small language models (SLMs): we look at model internals and train classifiers to detect which parts of the context carry the most signal. When a tool returns output, we compress it conditioned on the intent of the tool call—so if the agent called grep looking for error handling patterns, the SLM keeps the relevant matches and strips the rest.<p>If the model later needs something we removed, it calls expand() to fetch the original output. We also do background compaction at 85% window capacity and lazy-load tool descriptions so the model only sees tools relevant to the current step.<p>The proxy also gives you spending caps, a dashboard for tracking running and past sessions, and Slack pings when an agent is sitting there waiting on you.<p>Repo is here: <a href="https:&#x2F;&#x2F;github.com&#x2F;Compresr-ai&#x2F;Context-Gateway" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;Compresr-ai&#x2F;Context-Gateway</a>. You can try it with:<p><pre><code>  curl -fsSL https:&#x2F;&#x2F;compresr.ai&#x2F;api&#x2F;install | sh
</code></pre>
Happy to go deep on any of it: the compression model, how the lazy tool loading works, or anything else about the gateway. Try it out and let us know how you like it!


id: 4bd61f83571a
title: Launch HN: Captain (YC W26) – Automated RAG for Files
source_url: https://www.runcaptain.com/
source_platform: hackernews
author: CMLewis
published_at: 2026-03-13T15:45:33+00:00
collected_at: 2026-03-14T01:02:31.474036+00:00
scenario_type: 本地数据集成
tools_used: ["Captain RAG", "S3", "Google Cloud Storage", "Google Drive", "embedding models", "vector search"]
novelty: similar
similar_to_ids: ["39d6b08b7043", "85b23a6c94bb", "5ff4bf30ae94"]
summary:
Captain是一个自动化RAG（检索增强生成）平台，专门为非结构化数据搜索而设计，支持云存储和SaaS源的文件索引。通过自动处理ETL、分块、嵌入和搜索等复杂流程，大幅简化了RAG管道的构建和维护，相比手动实现的准确率提升6.5%-23.5%。

raw_content:
Launch HN: Captain (YC W26) – Automated RAG for Files

Hi HN, we’re Lewis and Edgar, building Captain to simplify unstructured data search (<a href="https:&#x2F;&#x2F;runcaptain.com">https:&#x2F;&#x2F;runcaptain.com</a>). Captain automates the building and maintenance of file-based RAG pipelines. It indexes cloud storage like S3 and GCS, plus SaaS sources like Google Drive. There’s a quick walkthrough at <a href="https:&#x2F;&#x2F;youtu.be&#x2F;EIQkwAsIPmc" rel="nofollow">https:&#x2F;&#x2F;youtu.be&#x2F;EIQkwAsIPmc</a>.<p>We also put up this demo site called “Ask PG’s Essays” which lets you ask&#x2F;search the corpus of pg’s essays, to get a feel for how it works: <a href="https:&#x2F;&#x2F;pg.runcaptain.com">https:&#x2F;&#x2F;pg.runcaptain.com</a>. The RAG part of this took Captain about 3 minutes to set up.<p>Here are some sample prompts to get a feel for the experience:<p>“When do we do things that don&#x27;t scale? When should we be more cautious?” 
<a href="https:&#x2F;&#x2F;pg.runcaptain.com&#x2F;?q=When%20do%20we%20do%20things%20that%20don&#x27;t%20scale%3F%20When%20should%20we%20be%20more%20cautious%3F">https:&#x2F;&#x2F;pg.runcaptain.com&#x2F;?q=When%20do%20we%20do%20things%20...</a><p>“Give me some advice, I&#x27;m fundraising” 
<a href="https:&#x2F;&#x2F;pg.runcaptain.com&#x2F;?q=Give%20me%20some%20advice%2C%20I&#x27;m%20fundraising">https:&#x2F;&#x2F;pg.runcaptain.com&#x2F;?q=Give%20me%20some%20advice%2C%20...</a><p>“What are the biggest advantages of Lisp”
<a href="https:&#x2F;&#x2F;pg.runcaptain.com&#x2F;?q=what%20are%20the%20biggest%20advantages%20of%20Lisp">https:&#x2F;&#x2F;pg.runcaptain.com&#x2F;?q=what%20are%20the%20biggest%20ad...</a><p>A good production RAG pipeline takes substantial effort to build, especially for file workloads. You have to handle ETL or text extraction, chunking, embedding, storage, search, re-ranking, inference, and often compliance and observability – all while optimizing for latency and reliability. It’s a lot to manage. grep works well in some cases, but for agents, semantic search provides significantly higher performance. Cursor uses both and reports 6.5%–23.5% accuracy gains from vector search over grep (<a href="https:&#x2F;&#x2F;cursor.com&#x2F;blog&#x2F;semsearch" rel="nofollow">https:&#x2F;&#x2F;cursor.com&#x2F;blog&#x2F;semsearch</a>).<p>We’ve spent the past four years scaling RAG pipelines for companies, and Edgar’s work at Purdue’s NLP lab directly informed our chunking techniques. In conversations with dozens of engineers, we repeatedly saw DIY pipelines produce inconsistent results, even after weeks of tuning. Many teams lacked clarity on which retrieval strategies best fit their data.<p>We realized that a system to provision storage and embeddings, handle indexing, and continuously update pipelines to reflect the latest search techniques could remove the need for every team to rebuild RAG themselves. That idea became Captain.<p>In practice, one API call indexes URLs, cloud storage buckets, directories, or individual files. Under the hood, we’re converting everything to Markdown. For this, we’ve had good results with Gemini 3 Pro for images, Reducto for complex documents, and Extend for basic OCR. For embedding models, ‘gemini-embedding-001’ performed reasonably well at first, but we later switched to the Contextualized Embeddings from ‘voyage-context-3’. It produced more relevant results than even the newer Voyage 4 models because its chunk embeddings are encoded with awareness of the surrounding document context. We then applied Voyage’s ‘rerank-2.5’ as second-stage re-ranking, reducing 50 initial chunks to a final top 15 (configurable in Captain’s API). Dense embeddings are just half the picture and full-text search with RRF complete our hybrid retrieval. In the Captain API, these techniques are exposed through a single &#x2F;query endpoint. Access controls can be configured via metadata filters, and page number citations are returned automatically.<p>The stack is constantly changing but the Captain API creates a standard interface for this. You can try Captain, 1 month for free, and build your own pipelines at <a href="https:&#x2F;&#x2F;runcaptain.com">https:&#x2F;&#x2F;runcaptain.com</a>. We’re looking for candid feedback, especially anything that can make it more useful, and look forward to your comments!


id: b84b9fe32380
title: My Favorite Vibe Coding Workflow : r/vibecoding
source_url: https://www.reddit.com/r/vibecoding/comments/1r5zovv/my_favorite_vibe_coding_workflow/
source_platform: reddit
author: unknown
published_at: 2026-03-14T01:00:11.164780+00:00
collected_at: 2026-03-14T01:02:41.368035+00:00
scenario_type: 代码生成与审查
tools_used: ["Codex CLI", "Visual Studio Code", "ChatGPT", "Playwright", "Github"]
novelty: similar
similar_to_ids: ["ef284a502c1b", "8d0142693489", "c22de644b867", "5b6f4e63a641", "19e007cf2bb9", "4e8f450b17be"]
summary:
用户通过结合Codex CLI、ChatGPT和Playwright构建了一个高效的AI辅助编码工作流，核心在于先用ChatGPT详细规划功能避免代码重写，再用Codex CLI执行实现，最后用Playwright自动化测试验证。该工作流通过结构化提示和自动化测试显著提高了代码生成准确性和开发效率。

raw_content:
My Favorite Vibe Coding Workflow : r/vibecoding

My Favorite Vibe Coding Workflow : r/vibecoding Skip to main content My Favorite Vibe Coding Workflow : r/vibecoding

Go to vibecoding

r/vibecoding 2d ago

DesignedIt

# My Favorite Vibe Coding Workflow

I tried several different workflows (Codex within ChatGPT, regular ChatGPT, Opus/Claude CLI, Replit, RooCode, Cursor, Codex CLI in cmd, Codex CLI in VSC) and I found this to be the most efficient.

My largest hurdle was getting AI to stop breaking my features and stop repeating previous steps. I struggled with this 6 months ago but now focusing 90% of my time on step 2 with the planning phase completely fixed this.

Step 1: I use Codex CLI with the Visual Studio Code Codex extension and run it on xhigh reasoning. That’s been the biggest improvement in accuracy. Simple tasks usually take 30-60 seconds, most features take 1-2 minutes, and large system changes can take 3-8 minutes, but it gets things right on the first try way more often.

Step 2: If you just tell it to add a feature, it can sometimes rewrite or break existing functionality. So I always start by talking through the new feature or change with ChatGPT first. I’ll share screenshots and context, go back and forth on the best approach, and figure out exactly how the system should work before touching the code.

Step 3: Once the approach is clear, I ask ChatGPT to generate a clean implementation prompt based on what we discussed. This gives me a structured prompt that won’t cause random rewrites or break other features. The prompt from ChatGPT is usually pretty large and detailed -- much longer and more detailed than I would have typed out myself. ChatGPT pretty much plans out everything in much more detail than even Codex CLI in VSC would do in plan mode.

Step 4: I save that full prompt as a .txt file. If something breaks later, I can reattach that file (and up to 10 total files) to ChatGPT and generate a new fix prompt quickly without having to re-explain the whole system.

Step 5: I review and tweak the prompt if needed, then paste it into Codex CLI in build mode and let it implement everything. Sometimes I run plan mode first, copy the plan into ChatGPT to review, and then approve or adjust it before running the build. Editing the prompt is important because sometimes it will add unnecessary steps or you might have to copy and paste a specific secret or variable name or field in a database.

Step 6: I installed the Playwright skill through Codex CLI so it automatically navigates my SaaS, clicks through pages, runs frontend checks, executes backend unit tests, and takes screenshots. It basically tests the whole app for me.

Step 7: I have the Playwright script run tests twice, once with all feature flags turned on and once with them all turned off. Then do another 2 runs with unit tests for the backend. This catches most bugs or edge cases before deployment. I might figure out how to use Github hooks to run Playwright to reduce the runtime.

Step 8: I also have Codex update a readme document that includes all features implemented, notes about functions/features/systems, and anything else it feels like adding into there.

Step 9: I test the new feature that it just added in, and if it's working then I check in the files to GitHub.

Step 10: I also start out with a SaaS template that I built that saves months of work for each new SaaS so I don't have to setup the auth, billing, subscription tiers, credit database, add-on credit purchases, emails, and the UI. This lets me just focus on building the main tool for the site that I usually create in Python.

If anyone has any questions about this process just let me know. :) Does anyone use a different process?

Read more

Share

---

• Promoted

From pitch to working app in minutes. Build it with Base44 by describing what you want. Start building today.

---

Sea-Sir-2985

2d ago

the planning phase being 90% of the work is exactly right... i used to just throw prompts at the agent and wonder why it kept breaking things, but spending time upfront on a structured plan with clear constraints made a massive difference. the approach of using one model to generate the implementation prompt for another is smart too, basically using chatgpt as a prompt engineer for codex

one thing i'd add is keeping a CLAUDE.md or equivalent file that documents your project's architecture and conventions, so the agent has persistent context about how your codebase works instead of having to rediscover it every session

3

DesignedIt

2d ago

Maybe 70% of the work is planning and 20% is waiting for it to run 🤣. Half the times when it is running I am writing my next prompt though.

The file that you're talking about is what my step 8 is. I think I need to figure out a workflow how to have it automatically create this file and update it. Sometimes I notice that it automatically updates it. Sometimes I ask it to update it. What is you process for updating the file?

2

Continue this thread

Izrathagud

1d ago

Dont trust the implementation prompt. I had a gigantious spec chat with chatgpt over 5 days and asked it to summarize it all without any details lost. I put that and the chatlogs into gpt again and told it to rate it on completeness. It gave it a 50% complete rating. So 50% of the stuff we talked about lost. I told it to fix it. Next iteration it was 65%, then 73%, etc.. It took 7 iterations to get to 97%. Each new gpt instance found about 7 new details missing even though i told it to walk trough the chatlog religiously.

3

DesignedIt

1d ago

Yeah, I always read over the implementation prompt from ChatGPT. I'll often change it around a little and sometimes tell it to "redo the prompt above but this time add feature X to it". Then I'll give it a quick read again and make sure it has everything this time.

As long as you attach the txt files of all previous prompts or are just using the same original chat window, then it should be able to reference the details so you can just say "add feature X" and it knows what that feature is without having to reexplain it. Adding a screenshot of your software if it's available also helps.

1

Continue this thread

goodtimesKC

1d ago

It can’t break anything if you have proper tests. And if it does break something with tests you know immediately when you run them. You have to learn something at least about coding to do this properly.

3

DesignedIt

1d ago

Any tips on testing? This is one area where I'm still learning how to automate it better and can improve upon. I had AI automatically setup automated tests using Playwright but think I need to define about 50 different tests with different combinations of flags turned on and off so it catches everything right away. I also manually test things and have been coding for 20+ years.

1

goodtimesKC

1d ago

Tests check for certain things to exist. If you have a test that says this pathway works then you do something to that pathway and run the tests it will fail. Then you know you broke something

2

3 more replies

Continue this thread Continue this thread Continue this thread

• Promoted

Scaling engineering output used to mean scaling engineering teams. Claude Code changes that math.

rhuangab

1d ago

I have a question about how you handle specific details. For example, in Step 2, do you provide the full database schema as context so ChatGPT maps the exact columns in the prompt, or does it generate a logical structure with placeholders that you manually fill with specific variables/database fields during the Step 5 review? Also, could you share an example of a plan after Step 5? Thank you!!

2

DesignedIt

1d ago

I built the SaaS portion of the website on Replit using Codex CLI. So Codex had access to the database schema stored in Replit. So I could just talk Codex in /plan mode and it would know what the fields are in the database, then I could copy and paste the plan from Codex to ChatGPT to revise it. Even though it had access to this info, I still usually manually looked up and typed the "table.field" names and secret names to make sure it's using the correct ones.

After moving it from Replit to Vercel/Render, I'm just developing the tool portion of the website and it doesn't need to access the database since I already setup that part. But if I did, I would probably just create a list of the tables and fields and attach that file or copy and paste the fields to ChatGPT. I don't plan on having the schema change -- it's pretty much locked in right now. Below are 2 other more elegant solutions that ChatGPT just gave me. After reading the info below, now it makes sense why Replit told me to add DATABASE_URL as a secret. I tried it out before and Codex was referencing my external database not stored in Replit, probably the Posgres db I'm paying for on Render.

----------ChatGPT:

You’ve basically got 2 ways to make Codex “see” your DB fields in VS Code:

# Option A (best): keep schema in your repo (Codex reads files)

If you use an ORM, make sure the schema/migrations live in git:

Prisma: commit`prisma/schema.prisma`+ migrations, and regenerate types with:

`npx prisma db pull`(introspects DB → updates schema)

`npx prisma generate`(regenerates client/types)

Drizzle: use drizzle-kit introspection to generate a`schema.ts` from your DB, then commit it:

`drizzle-kit introspect ...`

Once those files exist in your workspace, Codex in VS Code can read them because it can read/edit/run code in your workspace.

1

DesignedIt

1d ago

ChatGPT:

# Option B: let Codex connect to the hosted DB and introspect

Give your local project a read-only`DATABASE_URL`(Neon/Render/etc), then run the introspection commands above locally. Codex CLI can run commands in your selected directory (and if your environment has network access, it’ll work).

# Quick “do this”

Put`DATABASE_URL` in your local`.env`(read-only user if possible)

Run (or tell Codex to run):

Prisma:`npx prisma db pull && npx prisma generate`

Drizzle:`drizzle-kit introspect ...`

Commit the generated schema/types so Codex always “sees” fields even offline.

1

Continue this thread

DesignedIt

1d ago

Prompt Part 1:

Here's one prompt I have saved. It's too long to post as one comment so I'll post it as multiple comments. The text in bold is what I changed/added in myself. ChatGPT just pumped out all of these requirements after I talked to it for a few minutes.

Add a full “verified waitlist” system end-to-end.

Requirements:

User enters email and clicks Join Waitlist either on the landing page or on the pricing page.

Backend saves the email in a new waitlist table.

Backend generates a secure verification token and stores it (optionally with expiry like 48 hours).

Backend sends a Resend email with a verification link the user must click.

Clicking the link verifies them (marks waitlist record confirmed).

Prevent spam + duplicates.

Database

This is not part of the prompt but I had to tell it to add in 3 additional columns to this table later on so users could declare their bonus credits and discount after I turn off the flags.

Create a new table, e.g. waitlist_signups with columns:

id (pk)

email (unique, lowercase)

status enum/string: pending, confirmed, unsubscribed

verification_token (random, long)

token_expires_at (nullable)

confirmed_at (nullable)

source (nullable: “landing”, “pricing”)

created_at timestamp

Add a unique constraint / index on email.

1

DesignedIt

1d ago

Prompt Part 2:

Backend API (FastAPI)

Add endpoints:

POST /api/waitlist/join

Input:

email (required)

source optional

Behavior:

Normalize email to lowercase/trim.

Basic validation (tell user “invalid email” if invalid).

Anti-spam:

honeypot field support (if present and filled, silently succeed but do nothing).

rate limit per IP (simple in-memory is ok for now).

If email already exists:

If confirmed: return success message “Already on the list”.

If pending: rotate token + resend verification email (or just resend).

If new:

Insert row with status pending + token + expiry.

Send verification email via email_service.py (Resend).

Return:

Always return a friendly success message: “Check your email to confirm” (Existing is "🎉 Thanks for joining! We'll keep you updated." maybe change it to something like "🎉 Thanks for joining! Please check your email (and junk) to verify").

Also on the pricing page, add the firework animation that rains down when user clicks join waitlist button, just like you have it for the landing page.

POST /api/waitlist/verify

Input:

token (required)

Behavior:

Look up record by token.

If not found or expired: return error “Link expired, request a new one”.

If found pending:

set status = confirmed.

set confirmed_at now.

clear token (set null) so it can’t be reused.

Return success.

1

DesignedIt

1d ago

Prompt Part 3:

Frontend

Add a verify page/route:

/waitlist/verify?token=... (or /waitlist/verify/[token])

On load:

Read token from URL.

Call POST /api/waitlist/verify.

Show success UI:

“You’re confirmed on the waitlist.”

If expired/invalid:

show “Link expired” + allow re-entering email to re-send.

Also update the Join Waitlist form submit:

Call POST /api/waitlist/join.

Show success toast/message: “Check your email to confirm”.

Disable button while loading.

This waitlist block should only render when NEXT_PUBLIC_FEATURE_JOIN_WAITLIST === true.

1

rhuangab

1d ago

Thanks for the detailed breakdown! I appreciate you taking the time to share this example.

2

1 more reply

Continue this thread Continue this thread

DesignedIt

1d ago

Prompt Part 4:

Email sending (Resend)

Update email_service.py:

Add a function like:

send_waitlist_verification_email(to_email: str, app_name: str, app_domain: str, verify_url: str)

Email content requirements:

Subject: “Confirm your {AppName} waitlist signup”.

Body includes:

App name.

Link to the website (app_domain).

Message: “We’ll let you know when you can signup.”

Strong CTA: “Click to verify your waitlist signup”.

Include the verification link prominently (button + plain link fallback).

Use existing Resend configuration/env vars (don’t hardcode sender).

Follow the same style as other emails in this repo.

The verification link should be constructed as:

{APP_DOMAIN}/waitlist/verify?token={token}

(or the route you implement).

Notes / rules

Do NOT create a user account on waitlist join.

Store waitlist separately from users.

Keep responses generic (don’t leak whether an email exists).

Add minimal logging around join/verify (status, errors).

Add/update Alembic migration(s) for the table.

Implement all code changes needed across backend + frontend + migrations so it works end-to-end.

1

Continue this thread

Necessary_Pomelo_470

1d ago

Open Claude, tell him to make no mistakes. Open codex tell him to also make no mistakes.Leave both edit the same file

1

DesignedIt

1d ago

Ha ha :) Does this work?

1

Continue this thread

mysticdenim

1d ago

Can you share a sample report where u r working on thisv

1

DesignedIt

1d ago

What do you mean by a sample report? What step is it for?

1

Continue this thread

PartOfTheTribe

1d ago

Can I do playwright w Claude code?

1

DesignedIt

1d ago

I just asked ChatGPT and it said Claude doesn't have a skills section for Playwright like Codex does. It gave a few options workaround options to use Playwright with Claude though if you ask it, such as installing it locally:

npm init -ynpm install -D playwrightnpx playwright install

But I think GitHub Actions is the best way to use Playwright which I'm going to do next. Codex was just easy to use with the built in skill to get me familiar with it and see how helpful it is and easy to use. I'm still new to using Playwright and am still learning. I always manually coded tests using Python/Selenium back in the old days lol, and now Playwright is 100 times faster with full automation.

1

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: c308aabe6a31
title: Used Claude Code to build a full-stack AI calendar app in a few weeks : r/vibecoding
source_platform: reddit
author: unknown
published_at: 2026-03-14T01:00:11.164799+00:00
collected_at: 2026-03-14T01:03:29.352379+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude Code", "Cursor", "Supabase", "Perplexity", "Vercel", "Sentry", "MCPs"]
novelty: similar
similar_to_ids: ["1f770ae13aa5", "c22de644b867", "ef284a502c1b", "cba07222d406"]
summary:
开发者使用Claude Code在几周内构建了一个全栈AI日历应用，通过集成Supabase、Perplexity等工具的MCP来简化自然语言事件创建。该项目展示了Claude Code在代码生成、自动化模式和多工具集成中的实际应用价值，尽管仍需在某些场景下手动干预。

source_url:
https://www.reddit.com/r/vibecoding/comments/1mxffkg/used_claude_code_to_build_a_fullstack_ai_calendar/

raw_content:
Used Claude Code to build a full-stack AI calendar app in a few weeks : r/vibecoding

Used Claude Code to build a full-stack AI calendar app in a few weeks : r/vibecoding Skip to main content Used Claude Code to build a full-stack AI calendar app in a few weeks : r/vibecoding

Go to vibecoding

r/vibecoding 6mo ago

Mjd7373

# Used Claude Code to build a full-stack AI calendar app in a few weeks

ok so I got fed up with how annoying it is to actually create events in normal calendar apps. like why do I need to fill out 15 fields just to schedule a coffee?

spent a few weeks building my own thing where you literally just say "set up a meeting with sarah and john next tuesday" and it does everything - finds times, sends invites, the whole deal.

started in cursor but honestly claude code carried most of the heavy lifting. the game changer was hooking up supabase, perplexity, vercel and sentry through MCPs - everything just worked together without the usual integration hell. my workflow is basically let claude code run wild in auto mode, then jump back to cursor when it starts making stuff up lol

the dream is making scheduling feel like texting someone instead of filling out a government form. want it to work everywhere - slack, email, text, whatever. just shipped v1 so we'll see if people actually use it or if I'm just solving my own weird problems

anyone else go deep with claude code on full projects? how'd it treat you? thinking of using it for the marketing push too because why not double down on the AI thing

Share

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


id: e1859e355e0c
title: https://www.reddit.com/r/ClaudeCode/comments/1m5ujvb/automating_workflows_using_claude_code.json
source_url: https://www.reddit.com/r/ClaudeCode/comments/1m5ujvb/automating_workflows_using_claude_code.json
source_platform: reddit
author: t2_1tn7so7ksi
published_at: 2026-03-14T01:00:12.601102+00:00
collected_at: 2026-03-14T01:03:50.756372+00:00
scenario_type: 工作流自动化
tools_used: ["Claude Code", "Codex", "Blocks", "Playwright MCPs", "Sentry"]
novelty: similar
similar_to_ids: ["220851dd1119", "4188cb874081", "e9cce03581a0", "95b07c16360e", "bea33498d6bd"]
summary:
用户通过Claude Code和Blocks平台自动化多种开发工作流，包括PR审查（安全性、可访问性合规）、文档更新、Sentry问题分类和前端QA测试。这是一个成熟的工作流自动化案例，具有明确的业务价值和实际应用场景。

raw_content:
https://www.reddit.com/r/ClaudeCode/comments/1m5ujvb/automating_workflows_using_claude_code.json

One of the reasons I built Blocks (https://blocksorg.com/) was to automate developer workflows using Claude Code, and Codex like:

* Very specific types of PR Reviews (Security, Accessibility Compliance WCAG) as well as very specific types of checks/reviews specific to each repo
* Ensuring technical documentation is up to date
* Triaging issues coming from Sentry
* AI QA of frontend using Playright MCPs

I'm wondering what types of workflows anyone's tried automating using coding agents, which ones have worked well, and which ones have fell short. Or maybe you felt like you lacked the tooling to do so, would love to hear any thoughts!


id: 4a8b3582430c
title: The workflow that actually makes Claude Code fast (it's not what you think) : r/ClaudeCode
source_platform: reddit
author: unknown
published_at: 2026-03-14T01:00:12.601114+00:00
collected_at: 2026-03-14T01:04:13.600063+00:00
scenario_type: 工作流自动化
tools_used: ["Claude Code", "Git Worktrees", "Documentation", "CLAUDE.md"]
novelty: similar
similar_to_ids: ["220851dd1119", "4188cb874081", "d3a49d8714eb", "93d2c2bcd5d9", "6fe122c430d7"]
summary:
用户分享了使用Claude Code提高开发效率的实战工作流，核心要点包括：维护详细文档而非依赖模型猜测、每个会话前制定计划、使用Git Worktrees并行处理多个分支以充分利用推理等待时间。这套方法论通过优化上下文和并行工作流，显著提升了代码生成的质量和开发速度。

source_url:
https://www.reddit.com/r/ClaudeCode/comments/1r8oaef/the_workflow_that_actually_makes_claude_code_fast/

raw_content:
The workflow that actually makes Claude Code fast (it's not what you think) : r/ClaudeCode

The workflow that actually makes Claude Code fast (it's not what you think) : r/ClaudeCode Skip to main content The workflow that actually makes Claude Code fast (it's not what you think) : r/ClaudeCode

Go to ClaudeCode

r/ClaudeCode 23d ago

energee

# The workflow that actually makes Claude Code fast (it's not what you think)

Most of us started the same way with Claude Code. Prompt, wait, review, fix hallucinations, prompt again, maybe get stuck in a bug for a while. I was doing the same things over and over and wondering why it didn't feel that much faster than just writing the code myself.

After many months of iteration, I started to find things that work and consistently move things forward at a genuinely fast pace - here's what actually made the difference, YMMV.

Documentation, not the model, is doing the heavy lifting

This was the single biggest contributor to getting the right results for me. When people say "Claude got nerfed" or "the model is worse," nine times out of ten the model is choking on context, not declining in capability... but even if it is, make the problem the model has to solve, simpler.

I hit this hard on an application with a huge amount of data + relationships. Claude kept duplicating object structures, reinventing existing patterns. And when you start getting a couple sessions of good output, it's easy to get wrapped up in shipping fast and stop scrutinizing what's generated.

When the codebase gets larger, keeping what matters in context gets harder. Claude Code is damn good at parsing a codebase, but once I started maintaining real documentation, the output quality jumped. This is just architecture, requirements, and implementation docs with an index, referenced from CLAUDE.md, not spec-kit, not beads, just be sure to maintain it.

The model stopped guessing because it didn't have to - docs require less context than interpreting code. This ain't magic yet, the same things that make codebases maintainable for teams work with CC.

Plan before you code, every session

I pressure-test a plan with Claude before writing a line of implementation. This sounds obvious but I used to skip it on smaller features and it always bit me, even if I didnt realize it until later on. Review the plan doc every session, not just the first one, keep it maintained, tell CLAUDE.md to help you maintain it, it will help.

Git worktrees for parallel workstreams

Each Claude Code session gets its own branch in its own directory via git worktrees and each can run their own environment, just assign new port(s) for web apps. I might have a UX enhancement branch, 2 new feature branches, and a polish branch all active at once. While one track is inferencing, I'm spinning up the next or validating the last. (Tip: add a sound to the claude Stop hook, in settings.json). This is where the speed actually comes from, you're waiting anyway, this is the right time to be reviewing output, diffs, or running functional tests on your worktree.

TDD, but watch for the shortcut problem

Write tests first, you can write them in english but think about what features you want to protect, what is critical? TDD gives the model an executable definition of "done."

But here's the thing that burned me: Failing tests often are indicative of something breaking but if the tests aren't well-documented, Claude is more likely to make the test pass even if the change removes the value of the test.

When tests fail, Claude tends to take the simplest path to green. Weakening assertions, patching over the real issue, whatever gets there fastest. A failing test is a signal for you to inspect, not just a problem for the model to solve.

Type safety as guardrails

TypeScript strict mode, Pydantic, Zod schemas. Constraining the model's output so problems surface at compile time, not runtime. Probably obvious to most people here but worth stating because it mades a noticeable difference in how predictable the output is.

Atomic commits, manual review before merge

Small focused commits across parallel workstreams. Stage the PR and read the diff in GitHub with fresh eyes every time. Run the code-simplifier skill, use /code-review, you'd be surprised how much cleaner the output is after these two steps.

The whole system compounds. No single piece is revolutionary but stacked together it's a genuinely different experience than the prompt-and-pray loop.

What's working for you all?

Read more

Share

---

vocumsineratio

23d ago

Git worktrees for parallel workstreams

Have you been experiencing Claude having issues working with worktrees - I seem to be regularly running into problems where claude "forgets" that the common spellings of commands don't work in a worktree context, and I'd rather not make all of the mistakes first hand when trying to fix this.

1

energee

23d ago

Yes, even when using the worktree skill, which I assumed might address that.

When you clear context, even when using planning with "Yes, clear context and auto-accept edits" - it will move off the worktree and back to main, this should probably not be default behavior for worktree users since they probably don't want to leave the worktree until they close it.

I keep rules in Claude.md to catch this, but also, ensure that you see "Worktree: .worktrees/ (branch)" at the top of your plan before starting to implement, you might have to correct it if its missing from the plan before starting.

Also, consider adding a statusLine in claude settings.json to reflect current worktree, I show: • • so if i do miss it, i catch it quickly.

1

energee

23d ago

u/vocumsineratio not sure if you are talking about the same issue, but its what I've run into most.

1

Continue this thread Continue this thread

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

Expand Navigation Collapse Navigation


id: 27b37fa711af
title: Using Claude Code (an AI coding agent) has transformed my lab's research : r/academia
source_url: https://www.reddit.com/r/academia/comments/1rc6bt0/using_claude_code_an_ai_coding_agent_has/
source_platform: reddit
author: unknown
published_at: 2026-03-14T01:00:12.601120+00:00
collected_at: 2026-03-14T01:04:24.440491+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude Code", "Claude Pro", "Claude Sonnet/Opus"]
novelty: similar
similar_to_ids: ["1f770ae13aa5", "8d0142693489", "c22de644b867", "19e007cf2bb9", "c9f9395276c3"]
summary:
研究人员使用Claude Code等AI编码代理显著提升了STEM领域的科研效率，通过自动化代码生成、执行和调试，减少了重复性工作和人工干预。该应用展示了高级推理模型在学术研究中的合法且变革性的价值，特别是对需要大量编程的定量研究领域。

raw_content:
Using Claude Code (an AI coding agent) has transformed my lab's research : r/academia

Using Claude Code (an AI coding agent) has transformed my lab's research : r/academia Skip to main content Using Claude Code (an AI coding agent) has transformed my lab's research : r/academia

Go to academia

r/academia 1d ago

Living_Armadillo_652

# Using Claude Code (an AI coding agent) has transformed my lab's research

Note: not a single word of this post was written with an LLM. Not even revised for grammar or given any input from an LLM.

Recently, I noticed there's been a lot of examples of bad uses of AI in academia in this subreddit, especially in academic writing and teaching. However, in the interest of balance, I would like to highlight an example where I think AI use is not only useful and legitimate, but transformative.

Some disclaimers:

my field is STEM (physical sciences), and a lot of our research activities require coding and execution of software. A lot of what I'm saying is not going to be applicable to humanities fields which don't operate in this way. But I have come across similar positive experiences regarding AI from researchers in fields such as economics and political science who do quantitative studies and thus also need to write a lot of code.

none of what I say below is applicable to the free tier of ChatGPT and other LLMs, which seems to be most people's (including academics') experience with AI. Such models are still fairly weak for serious academic work - I never trust them for anything beyond easy undergraduate-level questions. But there is a world of difference if you use the latest reasoning models which requires a subscription (whether ChatGPT 5.2, Gemini 3 Pro, Claude Sonnet/Opus 4.6, etc.) - the rate of hallucinations just drops by a lot, and you get much more useful output. Also, while I am using Claude Code, what I'm saying is also applicable to other autonomous coding agents such as GPT-5.2-Codex. Claude Code just happens to be the best tool on the market at this moment for what we do; this could completely change within a month or two.

Anyway, having read about software engineers using Claude Code and claiming they never had to write another line of code again, about three weeks ago I decided to pay for a $20 subscription to Claude Pro, which gives me access to Claude Code. Unlike regular ChatGPT, Claude, and other chatbots, Claude Code is an agent: with your permission, it can automatically read and edit your files directly, create new code and also execute it. This means that if you prompt it properly, it can finish complex tasks without needing much user intervention. So you don't need to copy-paste code snippets from a chat window anymore. This agentic, self-feedback capability is crucial, because sometimes an AI will first give you incorrect code that doesn't work - but here, the AI agent will try to run that code, then quickly figure out that it gives an error or a nonsensical result, revise its output and try again until it converges to something reasonably approximating your instructions.

I first tried to use Claude Code to extend data analysis code we already had to perform new statistical tests. With only a few prompts it was able to understand all of the code that we had written before, write new code to implement the new data analysis I wanted, run it on my data, and report the results. All I needed to do was give it enough detailed information about what I wanted, supervise it as it worked, and question if the results don't make sense (as it does sometimes make errors). Within that first weekend of using Claude Code, I was able to accomplish what would probably take myself a whole week of dedicated manual coding.

I immediately told the grad students I supervise about this and they started trying it out, and it's transformed many things we do. We no longer write significant data analysis code anymore - we just write a detailed technical description (in natural human language, as if you're talking to a human research assistant) of what the data is, what we exactly we want to do with it, and what outputs we want, and Claude Code will just execute it in Python. The same goes for making simulations of physical models - we now only need to focus on the scientific model itself - no need to think about the technical syntax of the code, how to install the software package, or all these non-scientific details that were previously a high barrier to entry.

Another good application is trying to figure out how to control scientific instruments in the lab. Previously, it would take a lot of time reading the manual, finding the right drivers, command syntax, and troubleshooting everything - sometimes this would take days. Now, I just need to connect the hardware physically and tell Claude Code what I have connected, what I want to do with the instrument, and maybe point it to the PDF of the manual or a folder which may contain the right driver. Within 10-15 minutes Claude can autonomously figure out how to communicate with the instrument, how to send commands, read outputs, and even make a whole customized GUI program for us to control it ourselves. Claude Code has been so transformative in these ways that I've upgraded to a $200/month subscription.

To be clear, the human role is still critical. Claude is not good enough to autonomously execute a whole research project without extensive human involvement in ideation, supervision, verification, and auditing. It sometimes makes errors if your instructions are not thorough enough. Most importantly, Claude Code can only reliably solve tasks which have a clear, quantifiable, verifiable, and tightly scoped objective, which is only a small subset of academic research tasks. In my view, writing an academic paper is NOT one of those tasks - I actually don't use LLMs nearly as much for academic writing.

But gone are the days when I would spend weeks just to code some very complex data analysis or experimental control software. In fact, I spend more time now thinking and planning about the science itself - writing detailed multi-paragraph prompts on what I want to do before sending it to Claude Code and letting it execute, then checking back in a few hours later. I am now able to realize many projects which were previously just distant plans on my wish list - not having to code lowers the cognitive workload of these projects by a lot. On the darker side, this also means that I will likely take on less undergraduates as research students - I have no use for people who in the past would mostly just do the labor of coding and technical troubleshooting while relying on their mentor to give them intellectual direction. Instead, I need people who are intellectually mature so that they contribute to the research effort more than myself telling Claude Code to do it.

Unfortunately being an experimental scientist, I am limited by hardware - humans are still needed to actually physically build and carry out our experiments, even if controlling and analyzing them can now be massively sped up with AI. But I can see purely computational research groups having an even greater productivity boost than my group. My bold prediction is that in the next year, many academics in a similar field of research like mine will start to catch on to AI coding agents, and for many people there will be no choice but to use them as well to keep up with the pace of the rest of the field. The reality is that the vast majority of us are not geniuses who can regularly think of brilliant creative research ideas that no AI yet knows about or replicates. Instead, most of us are doing incremental research work - using established methods and applying them to semi-newish domains, and this is where AI can really make a difference.

Read more

Share

---

• Promoted

That side project. The migration you’ve been avoiding. The feature stuck in backlog. Claude Code helps you finally ship it

---

ktpr

1d ago

How do you know the data analysis is correct if you prompt exactly what you want to do with it, including the outputs? LLMs can be very sycophantic.

6

Living_Armadillo_652

1d ago

That's a very legitimate concern, and I'm still figuring out the best way to deal with that. After all, we just started doing this three weeks ago, and we haven't yet published anything from it. Right now, our strategy is a mix of 1) manual human verification of critical parts of the code, 2) asking Claude Code to output intermediate data analysis results and checking them manually at each stage, 3) sanity checks: analyzing synthetic datasets with the same code and seeing if it gives the results you expect, and 4) asking Claude Code and other coding agents to audit the code itself, which sometimes turns up issues and fixes them. Note that verification still takes up much less time and cognitive load than doing the task manually (just like grading is usually easier than doing the exam), so the productivity boost from AI is still there even with the need to do extra verification steps.

An important factor is that what Claude does is not a complete black box: you can see what scripts it's writing and executing, what files it's generating, and so on. So I know it's not just making up data analysis results from nothing - I can see the plots, log files, and other outputs which it generates, which are often messy, sometimes error-ridden, and not very "sycophantic" at all - exactly reflecting the uncertain nature of the statistical procedures we're applying.

In the case of physical experiments controlled by Claude-generated code, verification is more straightforward: we can physically change the state of the experiment and test if the software gives the response we expect. In that case it's not different from human-generated code.

I'm slowly converging to the position that this is not that different from supervising a research student: you don't have the time to manually check every line of code and every piece of output they generate. Instead, you pick random, usually critical parts of their output and check if it makes sense. I apply a similar principle to AI-agent-driven work.

3

Continue this thread

Opening_Map_6898

1d ago

Thanks ChatGPT.

6

Living_Armadillo_652

1d ago

I have to be clear, not a single word of that was written with an LLM. That was me spending 30 minutes to write that word-by-word. And if you've actually used ChatGPT a lot to write you would know.

-5

[deleted]

1d ago

Comment deleted by user

2 more replies

Continue this thread Continue this thread

SciTraveler

1d ago

I agree. I've had similar experience. This isn't the future; it's the present.

0

Opening_Map_6898

1d ago

Found the other bot!

2

ThrasymachianJustice

17h ago

This isn't the future; it's the present.

Real people don't talk this way.

1

SciTraveler

15h ago

Don't spend a lot of time around academics, do you? 😉

-1

1 more reply

Continue this thread Continue this thread Continue this thread

---

## View Post in

हिन्दी

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


id: 7765e623bebd
title: hesreallyhim/awesome-claude-code
source_url: https://github.com/hesreallyhim/awesome-claude-code
source_platform: github
author: hesreallyhim
published_at: 2026-03-14T00:32:21+00:00
collected_at: 2026-03-14T01:04:33.361901+00:00
scenario_type: 终端与CLI增强
tools_used: ["Claude Code", "agent orchestrators", "slash-commands", "plugins"]
novelty: similar
similar_to_ids: ["52d44a688882", "1d33fcd888f9", "faa318861b48", "abb1b9505bb9"]
summary:
这是一个为Claude Code汇总的精选资源列表，包含技能、钩子、斜杠命令、代理编排器、应用程序和插件。该项目帮助开发者发现和整合Claude Code生态系统中的扩展工具，提升CLI工作流效率和自动化能力。

raw_content:
hesreallyhim/awesome-claude-code

A curated list of awesome skills, hooks, slash-commands, agent orchestrators, applications, and plugins for Claude Code by Anthropic

Topics: agent-skills, agentic-code, agentic-coding, ai-workflow-optimization, ai-workflows, anthropic, anthropic-claude, awesome, awesome-list, awesome-lists, awesome-resources, claude, claude-code, coding-agent, coding-agents, coding-assistant, coding-assistants, llm
Language: Python | Stars: 27983


id: 2587854ae526
source_platform: reddit
author: t2_21erqxgbwx
published_at: 2026-03-15T01:00:11.944933+00:00
collected_at: 2026-03-15T01:00:32.066180+00:00
scenario_type: 工作流自动化
tools_used: ["OpenClaw", "Claude Opus", "GPT-5.4", "Telegram"]
novelty: similar
similar_to_ids: ["93d2c2bcd5d9", "7e9bc69a52f6", "034f0f8b6fff", "9d622833f3fc"]
title:
https://www.reddit.com/r/AskClaw/comments/1rq4htj/10_things_i_learned_about_openclaw_i_learned_all.json

summary:
本文分享了使用OpenClaw智能代理的10个实战经验，重点包括启用完整工具集、避免配置文件截断、优化Token成本、选择合适模型等关键要点。这些经验针对AI代理工作流配置和优化具有实践参考价值，能帮助用户显著降低成本并提高效率。

source_url:
https://www.reddit.com/r/AskClaw/comments/1rq4htj/10_things_i_learned_about_openclaw_i_learned_all.json

raw_content:
https://www.reddit.com/r/AskClaw/comments/1rq4htj/10_things_i_learned_about_openclaw_i_learned_all.json

I've been running OpenClaw since the clawdbot days. I think I have made all the mistakes a newbie can make. Here's what cost me real money and wasted time.

**your agent isn't broken. you just tied its hands.**

First agent goes live. You ask it to read a file. Nothing. Run a command. Nothing.

It's not broken. You just didn't give it tools. The default tools profile was messaging only. Reading files, writing files, running commands, all disabled. You gave your agent a phone and a chair and wondered why nothing got done.

 "tools": { "profile": "full" }
 

One line changes everything. If you also need it to run commands without approval prompts (like on Telegram):

 "tools": {
 "profile": "full",
 "exec": { "security": "full", "ask": "off" }
 }
 

`profile` controls whether tools exist. `exec.ask` controls whether it asks before using them. Set profile first. The other way around does nothing.

**your most important rules might have never been read.**

I wrote a rule in AGENTS.md. My agent kept ignoring it. Switched to Opus. Still ignored.

Turns out the rule was in the middle of the file. OpenClaw has a 20,000 character limit per workspace file. Anything longer gets silently trimmed. It keeps the first 70%, the last 20%, and cuts the middle 10%. No error. No warning.

Check with `/context list` in chat. If you see `TRUNCATED`, something got cut.

Put your most critical rules at the top. The middle is the kill zone.

If your files genuinely need to be longer, adjust these:

 "bootstrapMaxChars": 20000,
 "bootstrapTotalMaxChars": 150000
 

**80% of your API spend is probably waste.**

Two weeks in I opened my token dashboard. 80% was input. My agent wasn't thinking. It was reviewing. Every turn, it reread the system prompt, tool definitions, SOUL.md, the full chat history.

One reader's numbers: 139M input, 935K output. A ratio of 148 to 1. His agent was injecting 52KB of context every turn. MEMORY.md alone was 22KB.

Fix: keep core rules in SOUL.md. Move everything else to the memory folder and let the agent fetch via semantic search. Tokens dropped 40-60% after that change. Output quality stayed the same.

**don't save money on the model. save your time.**

Cheapest model saved $20. Then came an hour fixing the output. Another hour re-explaining what went wrong. Rewrote the prompt. Ran it again. Switched back to the top model. Worked first try.

That said, not every agent needs the same model. Agents talking to humans need Opus: tone, emotion, writing like a person. Agents pulling data, scanning notifications, sorting content actually work better on GPT-5.4. Faster, more stable, more obedient. Opus overthinks simple tasks.

 agents:
 defaults:
 model:
 primary: "openai/gpt-5.4"
 list:
 - id: community-bot
 model: "anthropic/claude-opus-4-6"
 
 This isn't about saving money. It's right tool, right job.
 your memory system will collapse after three weeks.
 MEMORY.md looks clean on day one. Three weeks later it's a junk drawer. Last month's outdated decisions sitting next to today's plans. Agent can't tell old from new. Regularly picks up month-old information and treats it as current fact.
 You don't need a three-tier memory architecture from the start. Turn on OpenClaw's built-in hybrid search and temporal decay. Newer memories get higher weight. Older ones decay automatically. No manual cleanup. 80% of memory problems gone.
 Memory problems are discovered by running, not by designing. Run first.
 the agent whose output nobody reads is your cost black hole.
 I built an entire pipeline once. Coordinator, analyst, strategist, editor, operations. Good org chart on paper.
 Half the agents were producing output every day and no agent or person was consuming any of it. Daily reports nobody read. Analysis nobody checked. Approval workflows where nothing needed approving.
 Before any agent starts, it has to answer three questions:
 1. what do i produce
 2. who receives my output
 3. what do i never touch

Can't answer question 2? The role shouldn't exist. I ran this across all my agents. Cut one. Tokens dropped 44%. Speed up 62%.

**five agents should not share one room.**

By month three, all five agents were talking in one Telegram group. Daily briefs mixed with runtime alerts. Customer support tangled with content planning. I was spending time each day just scrolling to find things.

OpenClaw supports per-topic routing. One Telegram forum, multiple topics, each bound to a different agent:

 channels:
 telegram:
 groups:
 "-100xxxxxxxxxx":
 topics:
 "daily-brief": { agentId: "nexus" }
 "radar": { agentId: "scout" }
 "content": { agentId: "quill" }
 "runtime": { agentId: "forge" }
 "support": { agentId: "guide" }
 

Each topic gets its own session, its own workspace, its own memory. Separate rooms. It changes everything.

**your agent doesn't know who's actually talking to it.**

Your agent receives a message. It has no idea if it came from you, another agent, or an external system. It treats everything the same and executes.

OpenClaw's ACP bridge supports provenance mode:

 openclaw acp --provenance off # disabled
 openclaw acp --provenance meta # messages carry source labels
 openclaw acp --provenance meta+receipt # source labels + agent sees a visible origin receipt
 

`meta` lets the system know where a message came from. `meta+receipt` lets the agent see it too. At minimum, your agent should be able to check ID on messages coming through the ACP bridge.

**nobody reminded you to back up.**

Every tutorial covers installation. Nobody mentions backup.

I lost my entire config once. Rebuilt SOUL.md by hand. The rebuilt version was worse because I couldn't remember half the edge cases I'd encoded in the original.

OpenClaw now supports one-command backup:

 openclaw backup create
 openclaw backup create --only-config
 openclaw backup create --no-include-workspace
 openclaw backup verify &lt;archive&gt;
 

By default it archives local state, config, credentials, and sessions. Set it up before you need it.

**the architecture will build itself. just start.**

The biggest pattern I've seen: people install OpenClaw and immediately spend days drawing diagrams. How many memory layers? Which agents run Opus? What protocol between them?

Architecture diagram done. System hasn't run a single real task.

Do it the other way:

Day one: one agent, connected to Telegram, doing one thing you repeat every day.

Week one: it will break. Fix the tools profile, the rule truncation, the slow responses. That's the real learning.

Week two: check the token bill. Slim down bloated prompts. Pick the right model for the task.

Week three: add a second agent. Now you actually understand what "downstream consumer" means.

Week four: the architecture doesn't need your design. It grew itself from every problem you solved.

The first hour after installing matters more than the next month. Not because it requires much. Because it decides whether you keep going.


id: 29f2cccdf292
title: Show HN: GitAgent – An open standard that turns any Git repo into an AI agent
source_url: https://www.gitagent.sh/
source_platform: hackernews
author: sivasurend
published_at: 2026-03-14T13:41:25+00:00
collected_at: 2026-03-15T01:00:53.487223+00:00
scenario_type: 工作流自动化
tools_used: ["GitAgent", "Claude", "OpenAI Agents SDK", "CrewAI", "Google ADK", "LangChain", "GitHub Actions"]
novelty: similar
summary:
GitAgent是一个开源标准，通过将AI代理定义为Git仓库中的文件来实现跨框架的代理可移植性。通过agent.yaml、SOUL.md和SKILL.md三个核心文件，用户可以获得版本控制、分支管理、人工审核和审计追踪等Git原生功能，支持导出到多个主流AI框架。该方案特别适合需要版本管理和协作审查的AI代理工作流，降低了框架迁移成本。

similar_to_ids:
["4188cb874081", "220851dd1119", "e9cce03581a0", "6fe122c430d7", "97dcab4759c8", "c37165a31cd3", "5471379ee4ff"]

raw_content:
Show HN: GitAgent – An open standard that turns any Git repo into an AI agent

We built GitAgent because we kept seeing the same problem: every agent framework defines agents differently, and switching frameworks means rewriting everything.<p>GitAgent is a spec that defines an AI agent as files in a git repo.<p>Three core files — agent.yaml (config), SOUL.md (personality&#x2F;instructions), and SKILL.md (capabilities) — and you get a portable agent definition that exports to Claude Code, OpenAI Agents SDK, CrewAI, Google ADK, LangChain, and others.<p>What you get for free by being git-native:<p>1. Version control for agent behavior (roll back a bad prompt like you&#x27;d revert a bad commit)
2. Branching for environment promotion (dev → staging → main)
3. Human-in-the-loop via PRs (agent learns a skill → opens a branch → human reviews before merge)
4. Audit trail via git blame and git diff
5. Agent forking and remixing (fork a public agent, customize it, PR improvements back)
6. CI&#x2F;CD with GitAgent validate in GitHub Actions<p>The CLI lets you run any agent repo directly:<p>npx @open-gitagent&#x2F;gitagent run -r <a href="https:&#x2F;&#x2F;github.com&#x2F;user&#x2F;agent" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;user&#x2F;agent</a> -a claude<p>The compliance layer is optional, but there if you need it — risk tiers, regulatory mappings (FINRA, SEC, SR 11-7), and audit reports via GitAgent audit.<p>Spec is at <a href="https:&#x2F;&#x2F;gitagent.sh" rel="nofollow">https:&#x2F;&#x2F;gitagent.sh</a>, code is on GitHub.<p>Would love feedback on the schema design and what adapters people would want next.


id: f6845369e6c1
title: Show HN: Algorithms and Data Structures in TypeScript – Free Book (~400 Pages)
source_url: http://amoilanen.github.io/Algorithms-with-Typescript/
source_platform: hackernews
author: jsontwikkeling
published_at: 2026-03-13T12:15:11+00:00
collected_at: 2026-03-15T01:03:05.412739+00:00
scenario_type: 文档与内容处理
tools_used: ["Claude Opus 4.6", "Zenflow", "TypeScript", "GitHub"]
novelty: new
similar_to_ids: []
summary:
作者利用Claude Opus 4.6和Zenflow AI工具完成了一部400页的算法与数据结构TypeScript教科书,涵盖排序、动态规划、图论等CS课程内容,所有代码都经过类型检查和测试。这是一个成功的AI辅助内容生成案例,展示了如何在规范驱动的工作流中利用AI快速完成大规模技术文档编写。

raw_content:
Show HN: Algorithms and Data Structures in TypeScript – Free Book (~400 Pages)

I started writing this book 10 years ago in JavaScript, got through a few
chapters (asymptotic notation, basic techniques, start of sorting), and
then abandoned it.<p>Recently I picked it back up, converted everything to TypeScript, and used
AI (Zenflow [1] + Claude Opus 4.6) to complete the remaining chapters. I
provided the structure, direction, and initial chapters; the AI generated
the bulk of the remaining content under a spec-driven workflow.<p>The book covers roughly a first 1-2 year CS curriculum: sorting, dynamic
programming, graph algorithms, trees, heaps, hash tables, and more. All
code is executable, typed with generics&#x2F;interfaces, and covered with tests.<p>I&#x27;ve thoroughly reviewed several chapters (sorting, DP, graphs) and done a
high-level pass on the rest. Currently in beta — corrections and
contributions are welcome.<p>MIT licensed. Inspired by Wirth&#x27;s &quot;Algorithms and Data Structures&quot;, SICP,
and CLRS.<p>Code and tests: <a href="https:&#x2F;&#x2F;github.com&#x2F;amoilanen&#x2F;Algorithms-with-Typescript" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;amoilanen&#x2F;Algorithms-with-Typescript</a><p>[1] <a href="https:&#x2F;&#x2F;zencoder.ai&#x2F;zenflow" rel="nofollow">https:&#x2F;&#x2F;zencoder.ai&#x2F;zenflow</a>


id: 517aee42d849
title: Show HN: Simple plugin to get Claude Code to listen to you
source_url: https://www.gopeek.ai
source_platform: hackernews
author: itsankur
published_at: 2026-03-13T23:15:22+00:00
collected_at: 2026-03-15T01:08:19.075863+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude Code", "融合搜索", "嵌入模型", "BM25"]
novelty: similar
similar_to_ids: ["4cbcc14ad9be", "8d0142693489", "5b6f4e63a641", "19e007cf2bb9"]
summary:
该插件通过融合搜索（embedding + BM25）和时间衰减机制，自动捕获和注入用户对Claude Code的纠正意见，解决了CC在plan模式后忽略markdown文件的问题。通过实时个性化上下文层，使AI代理能够理解用户的特定术语和工作方式，提高了代码生成工具的可控性和一致性。

raw_content:
Show HN: Simple plugin to get Claude Code to listen to you

Hey HN,<p>My cofounder and I have gotten tired of CC ignoring our markdown files so we spent 4 days and built a plugin that automatically steers CC based on our previous sessions. The problem is usually post plan-mode.<p>What we&#x27;ve tried:<p>Heavily use plan mode (works great)<p>CLAUDE.md, AGENTS.md, MEMORY.md<p>Local context folder (upkeep is a pain)<p>Cursor rules (for Cursor)<p>claude-mem (OSS) -&gt; does session continuity, not steering<p>We use fusion search to find your CC steering corrections.<p>- user prompt embeddings + bm25<p>- correction embeddings + bm25<p>- time decay<p>- target query embeddings<p>- exclusions<p>- metadata hard filters (such as files)<p>The CC plugin:<p>- Automatically captures memories&#x2F;corrections without you having to remind CC<p>- Automatically injects corrections without you having to remind CC to do it.<p>The plugin will merge, update, and distill your memories, and then inject the highest relevant ones after each of your own prompts.<p>We&#x27;re not sure if we&#x27;re alone in this. We&#x27;re working on some benchmarks to see how effective context injection actually is in steering CC and we know we need to keep improving extraction, search, and add more integrations.<p>We&#x27;re passionate about the real-time and personalized context layer for agents. Giving Agents a way to understand what you mean when you say &quot;this&quot; or &quot;that&quot;. Bringing the context of your world, into a secure, structured, real-time layer all your agents can access.<p>Would appreciate feedback on how you guys get CC to actually follow your markdown files, understand your modus operandi, feedback on the plugin, or anything else about real-time memory and context.<p>- Ankur


id: 9d8451ba2dcd
source_platform: reddit
author: t2_16hpzeam31
published_at: 2026-03-15T01:00:11.944990+00:00
collected_at: 2026-03-15T01:08:29.841112+00:00
scenario_type: 工作流自动化
tools_used: ["OpenClaw", "Anthropic API", "Claude (Opus/Sonnet/Haiku)", "Telegram"]
novelty: similar
similar_to_ids: ["2587854ae526", "93d2c2bcd5d9", "9d622833f3fc"]
title:
https://www.reddit.com/r/micro_saas/comments/1rotxms/i_thought_openclaw_would_save_me_time_instead_it.json

summary:
作者分享了在使用OpenClaw进行社交媒体内容自动化时的成本控制经验，发现无限制使用最昂贵的Opus模型导致意外的高API账单，通过为不同任务分配合适的模型（Haiku用于简单操作、Sonnet用于内容生成、禁用Opus）实现成本优化。这个案例强调了在构建自动化工作流时设置成本护栏和模型访问控制的重要性。

source_url:
https://www.reddit.com/r/micro_saas/comments/1rotxms/i_thought_openclaw_would_save_me_time_instead_it.json

raw_content:
https://www.reddit.com/r/micro_saas/comments/1rotxms/i_thought_openclaw_would_save_me_time_instead_it.json

A few weeks ago my co-founder and I started experimenting with OpenClaw.

We’re building **productlaunchpad.app**, a place where indie hackers can launch their projects and get discovered. The main constraint for us isn’t ideas or engineering. It’s time. We both work full-time, so automation sounded like the obvious lever.

The idea was simple. Use OpenClaw to generate and schedule social media content about ProductLaunchpad. We were building out the features and communicated with our OpenClaw agent using Telegram. This were going well, at least that is what i thought...

**Two days later I checked the Anthropic dashboard.**

**$57.76**

https://preview.redd.it/ns4pq1oj4zng1.png?width=680&amp;format=png&amp;auto=webp&amp;s=91528bc9323b4080c3e49c6008720a17d8fa9f00

My immediate reaction was: how did we spend this without actually shipping anything?

We weren’t running heavy jobs. No big scraping, no complex agents crawling the web. Mostly short prompts, quick iterations, and wiring things together.

Then I realized what happened.

Everything was running on the Opus model.

Opus is Anthropic’s most capable model. It’s also the most expensive. Using it for small operational tasks is basically like taking a Ferrari to buy groceries. You’ll get there, but you’re paying for performance you don’t need.

Once we saw it, the fix was obvious.

We changed the rules on what model to use. 

* Simple operational stuff like Telegram chat and commands now goes to Haiku. 
* Things that benefit from better writing, like copy, go to Sonnet. 
* And we removed Opus access entirely for now.

Not because Opus is bad. It’s excellent. But while you’re still figuring out workflows, letting an autonomous system freely use the most expensive model is a very efficient way to generate API bills.

The thing that surprised me is how little people talk about this.

Most OpenClaw discussions focus on what the agent *can* do. But if you’re building nights and weekends, cost management becomes part of the product.

**The main lesson for me: powerful tools need guardrails early.**

If I were starting again, I’d do this from day one:

* Default everything to Haiku. 
* Allow Sonnet only when it clearly adds value. 
* Disable Opus until the workflow is stable. 
* Set hard spending limits on the API.

Curious how other builders handle this.

If you're experimenting with agents or automation, how do you manage model costs and guardrails early on?


id: 87a318a4984d
title: Show HN: AgentArmor – open-source 8-layer security framework for AI agents
source_url: https://github.com/Agastya910/agentarmor
source_platform: hackernews
author: AgastyaTodi
published_at: 2026-03-14T09:44:36+00:00
collected_at: 2026-03-15T01:11:52.908717+00:00
scenario_type: 工作流自动化
novelty: similar
similar_to_ids: ["6885ba6c5ca2", "5471379ee4ff", "97dcab4759c8", "c37165a31cd3", "bc0fb2ea1445"]
summary:
AgentArmor是一个开源的AI Agent安全框架，通过8层独立的安全防护机制（从提示词注入检测到身份认证）为AI Agent工作流提供全面的安全保障。该框架支持Python库、FastAPI代理和CLI等多种部署方式，并已对OWASP ASI风险进行验证，适合在生产环境中保护多框架Agent的数据流和操作执行。

tools_used:
["AgentArmor", "LangChain", "OpenAI Agents SDK", "MCP servers", "Ollama", "FastAPI", "Microsoft Presidio"]

raw_content:
Show HN: AgentArmor – open-source 8-layer security framework for AI agents

I&#x27;ve been talking to founders building AI agents across fintech, devtools, and 
productivity – and almost none of them have any real security layer. Their agents 
read emails, call APIs, execute code, and write to databases with essentially no 
guardrails beyond &quot;we trust the LLM.&quot;<p>So I built AgentArmor: an open-source framework that wraps any agentic 
architecture with 8 independent security layers, each targeting a distinct attack 
surface in the agent&#x27;s data flow.<p>The 8 layers:
  L1 – Ingestion: prompt injection + jailbreak detection (20+ patterns, DAN, 
       extraction attempts, Unicode steganography)
  L2 – Storage: AES-256-GCM encryption at rest + BLAKE3 integrity for vector DBs
  L3 – Context: instruction-data separation (like parameterized SQL, but for 
       LLM context), canary tokens, prompt hardening
  L4 – Planning: action risk scoring (READ=1 → DELETE=7 → EXECUTE=8 → ADMIN=10),
       chain depth limits, bulk operation detection
  L5 – Execution: network egress control, per-action rate limiting, human 
       approval gates with conditional rules
  L6 – Output: PII redaction via Microsoft Presidio + regex fallback
  L7 – Inter-agent: HMAC-SHA256 mutual auth, trust scoring, delegation depth 
       limits, timestamp-bound replay prevention
  L8 – Identity: agent-native identity, JIT permissions, short-lived credentials<p>I tested it against all 10 OWASP ASI (Agentic Security Integrity) risks from 
the December 2025 spec. The red team suite is included in the repo.<p>Works as: (a) a Python library you wrap around tool calls, (b) a FastAPI proxy 
server for framework-agnostic deployment, or (c) a CLI for scanning prompts in CI.<p>Integrations included for: LangChain, OpenAI Agents SDK, MCP servers.<p>I ran it live with a local Ollama agent (qwen2:7b) – you can watch it block a 
`database.delete` at L8 (permission check), redact PII from file content at L6, 
and kill a prompt injection at L1 before it ever reaches the model.<p>GitHub: <a href="https:&#x2F;&#x2F;github.com&#x2F;Agastya910&#x2F;agentarmor" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;Agastya910&#x2F;agentarmor</a>
PyPI:   pip install agentarmor-core<p>Would love feedback, especially from people who have actually built production 
agents and hit security issues I haven&#x27;t thought of.<p>TAGS: security, python, llm, ai, agents


id: b1b1542da472
title: CherryHQ/cherry-studio
source_url: https://github.com/CherryHQ/cherry-studio
source_platform: github
author: CherryHQ
published_at: 2026-03-14T18:40:41+00:00
collected_at: 2026-03-15T01:13:04.917286+00:00
scenario_type: 终端与CLI增强
tools_used: ["Claude Code", "AI agents", "LLMs", "assistants"]
novelty: similar
similar_to_ids: ["52d44a688882", "1d33fcd888f9", "275d929bfde7", "0b5c4741d1c1"]
summary:
Cherry Studio是一个AI生产力工具平台，集成了智能聊天、自主代理和300+助手，提供对多个前沿大语言模型的统一访问。该项目通过提供代码代理和自动化功能，显著增强了开发者的生产力和工作流效率。

raw_content:
CherryHQ/cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants. Unified access to frontier LLMs

Topics: ai-agent, claude-code, code-agent, codex, openclaw, opencode, shannon, skills, superpowers, superpowers-core-skills, vibe-coding
Language: TypeScript | Stars: 41490


id: 0e4296f0f076
title: Vibe coding is actually great : r/ClaudeAI - Reddit
source_url: https://www.reddit.com/r/ClaudeAI/comments/1jhtrn0/vibe_coding_is_actually_great/
source_platform: reddit
author: eteitaxiv
published_at: 2025-03-23T00:00:00+00:00
collected_at: 2026-03-15T01:14:19.466353+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude Sonnet 3.7", "Chrome Extension API", "Flux API"]
novelty: similar
similar_to_ids: ["8d0142693489", "ef284a502c1b", "c22de644b867", "5de829326949"]
summary:
用户讨论"氛围编程"(vibe coding)的价值,强调AI辅助编程如何让非专业开发者能够快速构建所需工具和网站,实现编程民主化。作者通过Claude Sonnet成功创建了D&D网站、文本扩展器Chrome插件和Flux UI应用,证明了AI代码生成在实际项目中的可用性和价值。

raw_content:
Vibe coding is actually great : r/ClaudeAI - Reddit


 Vibe coding is actually great 
 Author: eteitaxiv 
 Time Posted (UTC): 2025-03-23 07:21:28+00:00 
 Score: 252 
 


 
 Link: https://www.reddit.com/r/ClaudeAI/comments/1jhtrn0/vibe_coding_is_actually_great/ 
 


 
 Everyone around is talking shit about vibe coding, but I think people miss the real power it brings to us non-developer users. Before, I had to trust other people to write unmalicious code, or trust some random Chrome extension, or pay someone to build something I wanted. I can't check the code as I don't have that level of skill. Now, with very simple coding knowledge (I can follow the logic somewhat and write Bash scripts of middling complexity), I can have what I want within limits. And... that is good. Really good. It is the democratization of coding. I understand that developers are afraid of this and pushing back, but that doesn't change that this is a good thing. People are saying AI code are unneccesarily long, debugging would be hard (which is not, AI does that too as long as you don't go over the context), performance would be bad, people don't know the code they are getting; but... are those really complaints poeple who *vibe code* care about? I know I don't. I used Sonnet 3.7 to make a website for the games I DM: https://5e.pub I used Sonnet 3.7 to make an Chrome extension I wanted to use but couldn't trust random extensions with access to all web pages: https://github.com/Tremontaine/simple-text-expander I used Sonnet 3.7 for a simple app to use Flux api: https://github.com/Tremontaine/flux-ui And... how could anyone say this is a bad thing? It puts me in control; if not the control of the code, then in control of the process. It lets me direct. It allows me to have small things I want without needing other people. And this is a good thing. 
 


 
 Comments 
 


 
 
 Comment by: PradheBand
 | Posted (UTC): 2025-03-23
 | Score: 161
 
 Vibe coding is for this. Low quality stuff done cheap. It is ok. It is just the step below the 50 buck low quality rent on fiverr. It is the marketing saying you can build a professional 50 million dollar turnover software company around vide coding that is bullshit. Well even a half million one... 


 
 
 Comment by: djerro6635381
 | Posted (UTC): 2025-03-23
 | Score: 22
 
 Exactly on point. Making coding and building solutions more attainable and available to more people is great! Doesn’t make anybody an engineer though, and I would even go as far as it pushes juniors in the wrong direction as they sometimes think they are on the right track because they can produce more lines of code. 

 

 
 
 Comment by: blazingasshole
 | Posted (UTC): 2025-03-23
 | Score: 8
 
 why not both vibe coding and then actual coding? I vibe code until I hit the wall where it doesn’t work anymore then I get my hands dirty and think about solutions myself 


 
 
 Comment by: Naive-Low-9770
 | Posted (UTC): 2025-03-25
 | Score: 1
 
 A lot of us are like this but you guys got to understand that programming as a whole is becoming a bigger space and the quality of people doing the right will decrease because the masses are always wrong and this is just another medium for the same thing. For what it's worth I had a friend working at some fresh uni grads that he'd hire for his company and he told me that the ones he hires use LLMs for the tedious stuff and do all the complicated stuff themselves or would have some sort of system around that 

 

 
 
 Comment by: Deathspiral222
 | Posted (UTC): 2025-03-27
 | Score: 1
 
 \>why not both vibe coding and then actual coding? I vibe code until I hit the wall where it doesn’t work anymore then I get my hands dirty and think about solutions myself Because the code is shit, that's why. If you are willing to throw all of the code away and start again, it's not a problem. If you are not, then it is. As a system gets bigger, the cost to add a new feature to the existing codebase grows exponentially. The worse the codebase is, the higher the cost. When the codebase is small, this doesn't matter much but eventually there is so much engineering debt that even trivial enhancements end up causing downtime and latency and security issues etc. The LLMs of today are only good enough to produce short chunks of code. Trying to rely on them to, say, write the next Facebook is never going to work out well. LLMs are the equivilent of a junior programmer you found on fiverr or an offshored programmer willing to work for pennies on the dollar. They are great for prototypes and small stuff but they don't scale up. It's like finding someone who is great at building small bridges out of lego and then asking them to build the Golden Gate. If using an LLM for a prototype helps you understand the problem better, I completely support using it, but I think it's unlikely that much of that original LLM code will every been seen in a large working system. 

 
 

 
 
 Comment by: Mike
 | Posted (UTC): 2025-03-23
 | Score: 4
 
 What marketing says that? 

 

 
 
 Comment by: qericr
 | Posted (UTC): 2025-03-23
 | Score: 3
 
 Vibe coding lowers my iq, makes me forget syntax, renders me incapable of thinking, and turns me lazy. 


 
 
 Comment by: jackiezhang95
 | Posted (UTC): 2025-03-28
 | Score: 1
 
 same thing with writers who say they write with pen somehow they think that makes them smarter compare to people who type 

 

 
 
 Comment by: Flylowbro
 | Posted (UTC): 2025-03-23
 | Score: -2
 
 I actually do not see how thats possible, thats the équivalent of saying using an Amazon kindle makes you forget how to read 


 
 
 Comment by: Iyace
 | Posted (UTC): 2025-03-25
 | Score: 2
 
 Amazon kindle isn’t reading books for you? What a shitty analogy. 


 
 
 Comment by: Flylowbro
 | Posted (UTC): 2025-03-25
 | Score: 1
 
 Actually it has assistive reader which reads the book outloud for you. 


 
 
 Comment by: Iyace
 | Posted (UTC): 2025-03-25
 | Score: 1
 
 Do if that’s all you did over time, you’d forget how to read lol. 


 
 
 Comment by: Flylowbro
 | Posted (UTC): 2025-03-25
 | Score: 1
 
 You’re stretching it, the main point is that there is a level of degradation from lack of use in the realm of cognitive ability 

 
 
 
 
 
 

 
 
 Comment by: Luss9
 | Posted (UTC): 2025-03-23
 | Score: 2
 
 Dude, theres VCs throwing millions into unrealized smoke projects that never deliver any product. Is it that outlandish to say that a vibe-coded app can get some of that as well? Im not saying everyone will do it. Just that if people are throwing money into fake never-actually-done-anything stuff, A vibe coded app could do it If well implemented. Heck theres even been companies that raise billions in bullshit marketing that never delivers anything. Im not saying vibe coding is gonna make you a billionaire, just that we will see some people do it and we will still be complaining about vibe coding and how its all bs. 


 
 
 Comment by: Niightstalker
 | Posted (UTC): 2025-03-24
 | Score: 1
 
 Well an we will see (and already saw) those companies who do so crash, because they encounter security, privacy, performance or other flaws, which can’t be fixed by vibe coding. In the best case it’s nothing major and they fix it in time (by paying an actual software engineer), in the worst case they e.g. already leaked customer data to the public, messed up some payment logic etc. Also fixing software created entirely by vibe coding will be a complete nightmare and often it would most likely faster to rewrite it from ground up. 

 
 

 
 
 Comment by: MyBikeFellinALake
 | Posted (UTC): 2025-03-24
 | Score: 1
 
 Meh, I've made a blender add on with 0 coding knowledge with only cursor that's raked in thousands of dollars. I just don't tell anyone because people hate vibe coding. But it's actually awesome and powerful. Just get high and spend an hour on cursor, did that for a couple weeks, even used it to make the website and blendermarket page. People seem to think it's not capable of making good work, but it is. It's really just how you prompt and organize your project. 

 

 
 
 Comment by: Hour-Negotiation-359
 | Posted (UTC): 2025-03-24
 | Score: 1
 
 A company is first a product market match, not lines of code. 

 

 
 
 Comment by: SubZeroGN
 | Posted (UTC): 2025-03-23
 | Score: -15
 
 Hahah, no and wait 1 year more. Even today in my job , my field of expertise , I generate 90% of the code with LLM and just double check. 


 
 
 Comment by: enspiralart
 | Posted (UTC): 2025-03-23
 | Score: 19
 
 then you're not vibe coding. I'm pretty sure vibe coding is when you don't double check and you just go with the vibe 


 
 
 Comment by: PradheBand
 | Posted (UTC): 2025-03-23
 | Score: 5
 
 This. Vibe coding is asking for code, do qa and if it fails asks the ai to fix the misbehaviour iteratively without checking the contents. In vibe coding ai codes you qa the output. Vibe coding doesn't require code understanging, it is just a nice to have. 

 
 

 
 
 Comment by: PradheBand
 | Posted (UTC): 2025-03-23
 | Score: 3
 
 Yeah and this is not vibe coding this is just AI generating the code, vibe coding is an entire different beast 

 

 
 
 Comment by: Minute-Flan13
 | Posted (UTC): 2025-03-23
 | Score: 2
 
 That 90% of code typically takes what with current tooling...20% of your time? That's been my experience, at least. Still doing the thinking, the LLM doing the grunt work. 

 
 
 

 
 
 Comment by: CMR30Modder
 | Posted (UTC): 2025-03-23
 | Score: 62
 
 The people complaining about vibe coding are largely developers that already know how to code to various degrees so are actually more capable of judging it. Not saying they are getting it right 100% of the time but many of the critiques are genuine. That being said I assure you there are many developers leveraging this tech. You would have to be a fool to ignore it. The truth is there is also a lot of resentment about this tech as well. The market was already over ran with an over population of untalented people and / or H1Bs destroying our economic value now we have AI and people like yourself. There is massive collusion in the industry to devalue our labor. Worst it is a matter of time before the hype matches reality. Many people would love if this tech was left to die. Anyhow I agree it is pretty great, just not as great as you are probably thinking as of today. It is just far more limited than what you have the experience to appreciate. 


 
 
 Comment by: sobe86
 | Posted (UTC): 2025-03-23
 | Score: 13
 
 > Worst it is a matter of time before the hype matches reality. Many people would love if this tech was left to die. I think this is it. I spent two decades learning a craft, it's how I make a living. The current iteration of LLMs can't replace me, but this is such new tech, I'm starting to feel it's a matter of 'when' rather than 'if', I am genuinely losing sleep about that. Personally I think others in the same position are in denial about this, they are honing in on the shortcomings and not acknowledging how scarily good it has gotten in such a short amount of time. Vibe coding is a good example here. It's doing the job quite amazingly well considering, but not good enough. Personally I'm mostly thinking about the first part of that sentence not the last. 


 
 
 Comment by: babige
 | Posted (UTC): 2025-03-23
 | Score: 5
 
 Come on man I understand there are levels to anything but as a dev you should also understand LLM's and their limitations, until they can create something new you will always have a job, and when AI reaches that point everyone is obsolete. 


 
 
 Comment by: bobtheorangutan
 | Posted (UTC): 2025-03-23
 | Score: 11
 
 Any decent dev definitely understand the limitations of LLMs, but at the moment, their bosses usually don't. I think that's where the current anxiety comes from. 

 

 
 
 Comment by: Salty-Garage7777
 | Posted (UTC): 2025-03-23
 | Score: 6
 
 Exactly - I cooperate with a friend whom I taught how to use Claude for coding, but all she ever does with it is HTML and CSS, cause these are the techs she used all her life.  When there was some strange PHP warning on her 10 year old Drupal 7 site she TRIED to ask Claude for help, to no avail. She asked me, I used my custom system of various LLMs, and debugged a total spaghetti code, written probably by some teenager (the friend always finds ways not to hire real Devs🤣) in 15 minutes. But in order to this I had to have the extensive knowledge of Drupal, PHP, prompting techniques, a logical mindset and a good reasoning capabilities and so on.  So LLMs are great tools, but only in the right hands! 😜😀 

 

 
 
 Comment by: sobe86
 | Posted (UTC): 2025-03-23
 | Score: 2
 
 But you're doing exactly what I said right, you're thinking about where it is, not how fast it's catching up. > and when AI reaches that point everyone is obsolete I find this less than reassuring. 


 
 
 Comment by: ChallengeFull3538
 | Posted (UTC): 2025-03-23
 | Score: 1
 
 I got access to manus yesterday - getting very worried about the future of this career. Its not perfect, but itd damn close. It made an MVP for me that would have taken me about 4 months - in less than 30 mins. Nextjs, authentication, firebase, stripe integration and a full marketing plan. Also implemented some features I didnt ask for that are actually really beneficial. Ive been a FE dev for a long time, and Im starting to get. very worried. Still going through the code manually though and there are a few issues, like not using a .env file etc and that is what if going to really hurt the people who dont know what theyre looking for. 

 

 
 
 Comment by: babige
 | Posted (UTC): 2025-03-23
 | Score: -2
 
 That response indicates you don't understand how LLM's aka statistical algorithms work, toodles. 


 
 
 Comment by: sobe86
 | Posted (UTC): 2025-03-23
 | Score: 7
 
 I work in AI, I finetune LLMs at work. I also have a PhD in math, and I've tried giving o3 etc recent problems from math overflow (research level math problems, out of training distribution). It's not _great_, but if you think these models are completely unable to solve anything out of distribution you are already mistaken. 


 
 
 Comment by: babige
 | Posted (UTC): 2025-03-23
 | Score: 1
 
 Can you build your own transformer model? If not then you don't understand how they work which is why you are vulnerable to the hype. If you did understand how they work you would agree with me, I'm not saying you are dumb, I'm saying based on their architecture LLMs could never create anything new, they are not intelligent, they are just transformers, encoding and decoding. 


 
 
 Comment by: sobe86
 | Posted (UTC): 2025-03-23
 | Score: 7
 
 \> Can you build your own transformer model? Yes I've done this in the past when they were new, nowadays I'd just use MultiHeadAttention from torch.nn. Why does the architecture matter though? We know that even a simple feedforward network satisfies the Universal Approximation Theorem, and should in theory be able to do anything a human can if we could make one big enough and set the weights to the right values (obviously, right now we can't). The only thing that really matters is how well they generalise to unseen problems, and I am telling you - they are doing this already. I think it is you who needs to stop thinking you know what these models are / aren't capable of and actually try to disconfirm your own beliefs. 


 
 
 Comment by: BrdigeTrlol
 | Posted (UTC): 2025-03-24
 | Score: 1
 
 UAT says that for any continuous function (although apparently 3 layered networks of some size may be sufficient for any discontinuous function) there exists at least some feedforward network that can approximate it, but it doesn't make any guarantees as far as to what method or size will be necessary to find/achieve this approximation. That means that while there is some network that can achieve any approximation, that network does not necessarily exist today and there is no guarantee that it will ever exist. LLMs are capable of generalizing, but not necessarily outside of their training data. Almost all generalization that LLMs perform can be considered interpolation. There is some evidence of limited extrapolation of some concepts in some models, but nothing to the degree that humans can achieve and it's typically quite unreliable. Continuous functions are easy enough, but most functions in nature are discontinuous. Without data to extend a function beyond what's been trained it's impossible to make meaningful extrapolations. LLMs still struggle very much so with extrapolation. The only reason why they appear to be able to generalize beyond their data is the amount and variety of training data as well as their monumental size. They don't capture information the way the human brain does. The human brain is able to model the world. LLMs are able to model human knowledge. Not exactly the same thing. In order to have new ideas you need to be able to explore the universe in all of its detail. LLMs don't have the means or even the capability to do so. 


 
 
 Comment by: sobe86
 | Posted (UTC): 2025-03-24
 | Score: 1
 
 UAT I brought up just to say there's not a good reason to believe a transformer as an architecture is incapable of AGI. I don't think any theoretical argument like that exists currently. The whole debate about in distribution / out of distribution has kind of shifted in the last few years. If I ask a model to debug some code I just wrote is that in distribution? What about if I ask it to give the answer as a freestyle rap? You could argue that code is in distribution, and rap is in distribution, and maybe even a small amount of rapping about code is - but to say this particular scenario is 'in distribution' is already stretching it a lot IMO. Your last paragraph is also a bit too human-supremacy to me too. How do humans solve problems? We think about similar problems we've seen and form links. We try to rephrase the problem, try to add or drop assumptions, try out different ideas and see where they lead. Reasoning model LLMs like o3 can genuinely do this to some extent already. I'm not talking about Einstein / Newton level stuff here - I'm talking about the problems that 99.9% of us thought workers actually do day to day - I can ask it questions I don't think it should be able to solve and it already gets there more often than I'm comfortable with. Whether or not that comes from the amount of training data / model size / whatever - who really cares? If it can replace you it can replace you, that's the worry. 


 
 
 Comment by: BrdigeTrlol
 | Posted (UTC): 2025-03-25
 | Score: 1
 
 Hm? If coding and rapping are both in the distribution then so is rapping about code. Again... It's called interpolation. Combining datasets. So it's not beyond, it's well within. Is it a form of generalization? Yes. But I wouldn't call that outside the dataset. Outside the dataset would involve something completely novel which that obviously doesn't. Almost all attempts at getting LLMs to achieve good performance/accuracy on truly novel ideas are largely unsuccessful. If you can explain the rules of it and it's similar enough to other things in the training set then they can do okay. If it's more complex and isn't easily/immediately deductible from data it's been given that's a whole other story. I don't say that to say humans will always be better, but it's ignorant to say that we aren't better at certain tasks (studies show this), especially the highest performing individuals tend to have a higher maximal performance than LLMs on many/most tasks. I say what I say to show that we need to do better. A lot of smart people also recognize this and are at work on the problem. Continually scaling to perform better isn't a viable solution to get the kind of performance we really want. AI that can do better than the smartest among us and lead us into a true revolution of ideas. 


 
 
 Comment by: sobe86
 | Posted (UTC): 2025-03-25
 | Score: 1
 
 Ok well that's all good - but this thread was about LLMs taking coders jobs, which according to you is well within distribution, what exactly are the non-geniuses of the world are going to do if these models keep getting better? 


 
 
 Comment by: BrdigeTrlol
 | Posted (UTC): 2025-03-25
 | Score: 1
 
 Well, you made a dubious claim that isn't supported by evidence. If we're talking about software engineers only a portion of lower level software engineers are at risk in the coming years. Unless they figure out how to do exactly what you claim they can do (generalize outside of training data). So it's not exactly irrelevant. Until they can operate autonomously and perform with very few (little to no errors), self-correct their errors when they make them or correct the errors of other LLMs with 100% success or accurately report their errors to a human with 100% success then you will always need a human in the loop even for things that they are generally better at. Because if you can't trust them to fix or identify their errors then you need people to verify the results. And if the work requires special knowledge... Well, the people who did the job in the first place aren't going anywhere. It's possible that LLMs with some modifications could achieve this, but there's no guarantee. And for anything novel enough LLMs won't be enough (not as they are anyway). And smart businesses will realize that they can make more money by doing more work with the same or similar number of employees (just as other technologies have done in the past). So it's really not so simple. Could half of everyone be replaced in a couple years? Yeah, I suppose so. Doesn't mean they will though. If the path was so straightforward we probably wouldn't be having this discussion in the first place. I have a feeling people have overestimated the complexity of work these models need to reliably be able to perform to be a complete replacement (people almost always underestimate how much work is required to fully realize any complex piece of technology). Is the world changing? Yes. Will some people lose their jobs in the next few years? Almost definitely. It's hard to say when full replacement will be possible for most or any jobs, however. Anything without mucb variation will be the first to be replaced. The more variation, the more difficult it will be to replace them. If we can have AI that continues to learn on the job and no longer hallucinates then a lot more people will have to worry. I guess we'll see how long that takes. 


 
 
 Comment by: babige
 | Posted (UTC): 2025-03-29
 | Score: 1
 
 That's my point although you've used superior language to get it across, llms will never be able to generalize beyond their training data accurately, or fix their mistakes with 100% accuracy, basically every swe moving forward has to be at the senior level to start. 

 
 
 
 
 
 

 
 
 Comment by: babige
 | Posted (UTC): 2025-03-23
 | Score: 0
 
 I see a lot of Coulds, in theory, etc.. with what accuracy can they generalize to unseen problems? Heck with what accuracy can they predict seen problems? It'll never be close to 100% you know this it'll always make mistakes especially with unseen problems, transformers will never reach AGI, we would need the sun just to power the compute for 1 hour 😂 and it'll still give incorrect answers! I said it once I'll say it again we will not have AGI until we have matured quantum processors. 


 
 
 Comment by: sobe86
 | Posted (UTC): 2025-03-23
 | Score: 2
 
 \> with what accuracy can they generalize to unseen problems? It doesn't matter - you were claiming they're incapable of ever doing a thing they are already doing. \> I said it once I'll say it again we will not have AGI until we have matured quantum processors. Why? Humans are AGIs, and are we using quantum mechanical effects for thought? I know Roger Penrose would say yes, but I don't know if the neuroscience community takes him all that seriously on this. I don't personally see any hard theoretical barrier to AGI right now, we need some more breakthroughs for sure, we're at least a few years out from it. But given the progress in the last decade it's hard for me to say something like "not before xxx happens". 


 
 
 Comment by: babige
 | Posted (UTC): 2025-03-23
 | Score: 1
 
 It does matter creativity requires accuracy at every inflection point, if not you could claim every hallucination is creativity something tells me you would 😆. I wouldn't call gibberish creativity. Any chance of a source for that reasoning claim? For the quantum chip, I'm with Roger, our brains are quantum computers that do incredible things with what 100 watts? I'm just speculating it's way out of my scope. 


 
 
 Comment by: sobe86
 | Posted (UTC): 2025-03-23
 | Score: 2
 
 Sure thing: here's chatGPT o3 trying to answer some tough recent math questions that I was pretty sure were not google-able / in training data. https://chatgpt.com/share/67e01737-0ef8-8002-a049-eeda2ee4c982 Note my responses - sometimes it's making bad errors. But the amount it's getting right or partially correct was \_shocking\_ to me. This stuff is way harder than e.g. everyday coding. 


 
 
 Comment by: babige
 | Posted (UTC): 2025-03-23
 | Score: 1
 
 Yeah that's way out of my league mathematically, but I guess I see what you mean, that is progress, I guess we will have to see who was right in the long run, peace. 

 

 
 
 Comment by: BentHeadStudio
 | Posted (UTC): 2025-03-23
 | Score: 1
 
 Can you put that into Grok V3 and let me know its output please? 

 
 
 
 
 
 

 
 
 Comment by: SommniumSpaceDay
 | Posted (UTC): 2025-03-25
 | Score: 1
 
 Current models are not vanilla transformer architecture though. 

 
 
 
 
 
 
 

 
 
 Comment by: Fickle-Swimmer-5863
 | Posted (UTC): 2025-03-23
 | Score: 8
 
 I’m very positive about LLMs. In the hands of experienced developers, they’re massive enablers. I also think professional software developers are often biased towards complexity. The ongoing tug-of-war between employers trying to devalue our labour and developers introducing ever more complex paradigms isn’t one-sided. From unneeded microservices and overused CQRS/event sourcing to the endless churn of web frameworks, we developers aren’t innocent lambs to the slaughter—we know exactly what game we’re playing. Much of this is “accidental complexity,” and if competition from empowered amateurs helps rein that in, forcing professionals to focus on delivering actual value rather than complexity for self-gratification or job security, that’s a net positive. That said, like “low-code” before it (whose smoke and mirrors BS I’ve recently witnessed first-hand), the current wave of “vibe coding” risks ignoring hard-won lessons in software development. Understanding the architecture and shape of a system, being able to debug effectively, tracing requirements, testing, CI/CD, and version control—these practices matter. They’ve been earned through decades of painful mistakes. Woe betide any organisation that forgets them. 


 
 
 Comment by: karasugan
 | Posted (UTC): 2025-03-23
 | Score: 4
 
 I wholeheartedly agree with you about the low-code part. To be honest, I kind of see the entirety of web development as a precursor to all of this. After everything even on the desktop was starting to get written in JavaScript and stuffed into a webview container - using libraries built on libraries built on libraries as crutches to make the tech work at all - the title of a "software developer" has suffered an inflation. (Disclaimer: I'm one of the dinosaurs who thinks apps being built in an engine designed to display rich text documents is utterly idiotic and applications on the web should have their own engine, not bloated html with additional tricks glued on it with gum and duct tape. I've learned web development, but stayed away from it for the most part as, as a technology, I think it's so utterly garbage.) I see a big difference between people who actually know what's happening e.g. on a platform in atomic level when certain instructions are given to it and masses of people who just do high level coding without even understanding how the library they are using works. This is why, nowadays, I'm personally never hired to build new fun stuff. I'm hired when the management has tried to build everything as cheap as they can (hiring whole teams that don't actually know how to create product level software), pumped hundreds of thousands of dollars/euros into it and still failed. Either complete or have the level of problems in their production software that it's a dumpster fire and their clients are pissed at them. Now, for me, it's utterly frustrating: if they would just listen to me right from the start, they would get there cheaper. They wouldn't have pissed off their clients. They wouldn't be scrambling to reach out to me NOW, when everything is on fire and should have been fixed a year ago. Anyways, I'm just ranting a tale of an industry that, in my professional opinion, everyone think is very easy and as such, should be built cheap. The reality is _not it_, pretty often, unless you're doing something very trivial. Web development, low-code and no-code have been enablers to this and LLM isn't really helping. That is what I'm personally frustrated about. Yeah, I'll have endless amount of work as long as you're using it - but every job I get is a fucking dumpster fire and it feels like I'm trying to fight windmills with this thing. Boss, I'm tired. 


 
 
 Comment by: studio_bob
 | Posted (UTC): 2025-03-24
 | Score: 2
 
 I honestly don't think the "job security through complexity" thing is something malicious on the part of devs. Rather, it comes from a specific corporate culture at companies like Google and Facebook where management-imposed competition can be harsh and developing new libraries and frameworks is a way to impress management and secure future employment or promotions. So I would disagree with the previous comment which suggested blame on the part of devs as if they were sabotaging the companies they work for selfish reasons. The buck, as ever, stops at the C-suite which has created an environment where building or implementing superfluous complexity is a survival strategy. 


 
 
 Comment by: karasugan
 | Posted (UTC): 2025-03-24
 | Score: 1
 
 Ah, that would explain it. Because I've worked in international projects for about half of my career and even so never witnessed any malicious intent from the developers. I have, however, witnessed this from the management - though these have also been singular cases and more of a statistical anomaly than a given fact. Nevertheless, I was shocked to watch that YT video a few months back and see the cheer and the affirmation for these types of actions in the comments. There were a number of SW developers saying "yeah, I do this-and-that on purpose..." which led me to ponder if it's a cultural thing. 

 
 
 
 
 
 More comments truncated...


id: 24717f8b983f
source_platform: reddit
author: t2_124r1r65
published_at: 2026-03-15T01:00:13.328692+00:00
collected_at: 2026-03-15T01:15:29.212659+00:00
scenario_type: 代码生成与审查
tools_used: ["VibeCheck", "Claude Code", "Cursor", "Windsurf", "Cline", "Aider"]
novelty: similar
similar_to_ids: ["517aee42d849", "5b6f4e63a641", "1f770ae13aa5", "ef284a502c1b"]
title:
https://www.reddit.com/r/vibecoding/comments/1rl7dwp/i_was_vibecoding_and_realized_i_had_no_idea_what.json

summary:
VibeCheck是一个辅助工具，通过在AI代码生成完成后提出问题来帮助开发者理解所生成代码的实际影响。该工具与多种AI编码工具集成，自动检查代码变更与需求的匹配程度，增强了vibe coding工作流中的代码审查和理解环节。

source_url:
https://www.reddit.com/r/vibecoding/comments/1rl7dwp/i_was_vibecoding_and_realized_i_had_no_idea_what.json

raw_content:
https://www.reddit.com/r/vibecoding/comments/1rl7dwp/i_was_vibecoding_and_realized_i_had_no_idea_what.json

More and more people are vibe coding but barely know what got built. You say "add rate limiting" and your AI does it. But do you know what your users actually see when they hit the limit? A friendly message? A raw 429? Does the page just hang?

VibeCheck asks you stuff like that. One question after your AI finishes a task, based on your actual diff. It looks at what was built, compares it to what you asked for, and checks if you know what changed in your product.

Works with any AI coding tool. Native integration with Claude Code (auto-quiz after every task), and a standalone CLI that works with Cursor, Windsurf, OpenClaw, PicoClaw, NanoClaw, Cline, Aider, or anything else that writes code and commits to git.

https://github.com/akshan-main/vibe-check


id: 954dc3a3a586
title: https://www.reddit.com/r/ClaudeCode/comments/1rmd5d8/claude_code_use_cases_what_i_actually_do.json
source_url: https://www.reddit.com/r/ClaudeCode/comments/1rmd5d8/claude_code_use_cases_what_i_actually_do.json
source_platform: reddit
author: t2_e92to
published_at: 2026-03-15T01:00:14.566215+00:00
collected_at: 2026-03-15T01:17:51.682118+00:00
scenario_type: 商业流程自动化
novelty: similar
similar_to_ids: ["383475726b14", "a6ba47795183"]
summary:
创业者使用Claude Code搭建的完整自动化系统，涵盖每日运营简报、语音指令处理、软件开发、内容管理和分析等多个业务环节。该系统集成多个数据源，通过AI代理处理从决策支持到代码实现的全流程，显著提高了单人创业公司的运营效率。

tools_used:
["Claude Code", "Google Calendar", "Reddit/X", "Substack", "YouTube", "Wispr Flow", "React", "TypeScript", "PHP", "MySQL"]

raw_content:
https://www.reddit.com/r/ClaudeCode/comments/1rmd5d8/claude_code_use_cases_what_i_actually_do.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: 7e916297581a
title: hesamsheikh/awesome-openclaw-usecases
summary: 这是一个OpenClaw用例集合项目，汇总社区贡献的OpenClaw使用场景来简化日常工作。项目本身是一个awesome列表格式的资源整理库，没有具体说明具体的工作流或应用场景。
source_url: https://github.com/hesamsheikh/awesome-openclaw-usecases
source_platform: github
author: hesamsheikh
published_at: 2026-03-14T12:08:53+00:00
collected_at: 2026-03-15T01:18:27.284190+00:00
scenario_type: 其他
tools_used: ["OpenClaw", "clawdbot", "moltbot", "openclaw-plugin", "openclaw-skills"]
novelty: similar
similar_to_ids: ["61a57c93de29"]
raw_content:
hesamsheikh/awesome-openclaw-usecases

A community collection of OpenClaw use cases for making life easier.

Topics: awesome-list, clawdbot, moltbot, openclaw, openclaw-plugin, openclaw-setup, openclaw-skills, usecase
Language:  | Stars: 24755


id: fb050128f45f
title: 13 AI tools that actually save me time and deliver real results - Reddit
source_url: https://www.reddit.com/r/automation/comments/1miyhbu/13_ai_tools_that_actually_save_me_time_and/
source_platform: reddit
author: t2_115gnx21bf
published_at: 2025-08-06T00:00:00+00:00
collected_at: 2026-03-15T01:18:37.586657+00:00
scenario_type: 工作流自动化
novelty: similar
similar_to_ids: ["2587854ae526", "bea33498d6bd", "e1859e355e0c", "95b07c16360e", "4188cb874081"]
summary:
该帖子分享了13款实用AI工具的个人使用体验，涵盖从内容生成、视频制作到笔记管理、会议记录等多个生产力场景。评论进一步补充了Anchor Browser和FuseBase AI Agents等自动化工具，展示了通过API和工作流集成实现流程自动化的实际应用。

tools_used:
["ChatGPT", "Veo 3", "Saner.ai", "Fathom", "Manus", "Genspark", "NotebookLM", "ElevenLabs", "Suno", "Grammarly", "V0", "Lovable", "Consensus", "Anchor Browser", "FuseBase AI Agents"]

raw_content:
13 AI tools that actually save me time and deliver real results - Reddit

There are many AI tools out there, they come and go with many hypes. I've tried a lot of them and here are the tools I'm actually using to increase productivity/create new stuff. Most have free options.

* ChatGPT - still my go-to for brainstorming, drafts, code, and image generation
* Veo 3 - Well, it makes realistic videos from a single prompt.
* Saner.ai - My personal assistant, I just chat to manage notes, tasks, emails, and calendar
* Fathom - Free AI meeting note takers, finds action items
* Manus / Genspark - AI agents that actually do stuff for you, handy in heavy research work
* NotebookLM - Turn my PDFs into podcasts, easier to absorb information
* ElevenLabs - AI voices, so real. Great for narrations and videos.
* Suno - Just play around with this to create music from prompts.
* Grammarly - I use this everyday, basically it’s like a grammar police and consultant
* V0 / Lovable - Turn my ideas into working web apps, without coding
* Consensus - Get real research paper insights in minutes. So good for fact-finding purposes.

What AI, automation agent make it to your tech stack? Tell me yours
| subreddit: automation | score: 199 | post_type: text

Comments:
[AyKFL (10)]: I am using a bunch of these too. Chatgpt, Elevenlabs, Fathom specially. One thats become a sleeper hit in my stack is anchor browser. It gives me cloud based browser sessions that I can control via API or plug into agent workflows.

I use it for:

* Automating dashboards that dont have APIs
* Logging into sites and scraping info for reports
* Letting agents do stuff on the web like filling forms, checking competitor pricing or navigating annoying portals

Way more stable than anything I tried with Puppeteer or browser extensions. It doesnt get a lot of hype but its saved me hours in manual tasks.
[Pavel_at_Nimbus (7)]: Awesome list! Curious, have you tried FuseBase AI Agents? They're like a team of personal assistants that do all the busywork for you. They handle everything from research to repetitive admin tasks, even offer 24/7 support without you constantly prompting. And they work across your entire workflow (like workspaces, browser, automation hub).

We have a collection of prebuilt agents but you can also create your own in just a few clicks. Plus, they can connect with your existing tools (we support MCP integrations). I'm the founder, so happy to answer any questions!
[MM1972IT (3)]: Is there any free ai tool for bookkeeping, budgeting, forecasting, etc?
[AutoModerator (2)]: Thank you for your post to /r/automation!
 
New here? Please take a moment to read our rules, read them here.

This is an automated action so if you need anything, please Message the Mods with your request for assistance.

Lastly, enjoy your stay!

*I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.*
[One-Flight-7894 (2)]: Solid list! It's refreshing to see AI tools that actually solve real problems instead of just being cool demos.

I'd add a couple that have been game-changers for business operations:

**Zapier alternatives** - Some of the newer automation platforms do everything Zapier does but cheaper and more powerful once you get past the learning curve. Great for complex workflows.

**Notion AI** - Not flashy, but incredible for turning meeting notes into action items and project documentation. The database integration is what makes it useful vs. standalone AI writing tools.

**AI-powered scheduling tools** - Simple but saves hours of back-and-forth emails. The AI handles time zone math and finds common availability automatically.

Question about your personal assistant tool - how does it handle context across different projects/clients? I've tried several "AI assistants" but they seem to lose track when juggling multiple contexts.

The key insight from your list is that the best AI tools enhance workflows you already have, rather than forcing you to adopt completely new processes. Most businesses fail at AI because they try to revolutionize instead of optimize.
[Digital_Voodoo (1)]: &gt; Zapier alternatives

Any suggestions regarding this?
[iamconsultoria (1)]: Make and Pipedream
[Quiet-Story-4397 (1)]: Real!
[fuckingmissanthrope (2)]: In my case these are the ai tools that i use on a regular basis and they indeed make life easier: 
1. Chatgpt and gemini 2.4 pro for coding and problem solving. 
2. Fathom for meeting notes 
3. Chatgpt and midjourney for image and design creations 
4. v0 and lovable for frontend 
5. Deepseek for code debugging 
6. Copilot for writing unit tests in js and python, diffblue for java based applications, keploy for golang based applications(the vs code extension and the pr agent, both are top notch) 
7. Keploy for integration and api testing (I got to know about this tool recently and i suggest this to everyone to try) there's a web extension too that auto records api calls, generates curls and creates tests using ai, saves me a lot of time and energy daily.
[AIStudiosOfficial (2)]: Love this list! A few others I’ve been using lately:

* **DeepBrain AI Studios....**great for turning scripts into avatar videos without filming. You can even upload your own voice or sync with ElevenLabs.
* **Heygen....**similar vibe, but more template-heavy. Depends on what you’re making.
* **Durable....** if you need quick landing pages or sites, it’s shockingly fast.
* **Genmo....** fun for creative AI videos, kind of trippy sometimes but great for inspiration.

Definitely bookmarking your stack... lots of gems here 🔥
[Sir_Herpes (1)]: +1 for Genspark.
[TrueTeaToo (1)]: Yes but I think it hallucinates more than Manus
[MM1972IT (1)]: Thanks, will check it out
[YangBuildsAI (1)]: I’ve also been getting a lot of value out of Perplexity for quick research and Codeium as a lightweight coding copilot. Definitely curious to try Veo 3, haven’t played with that one yet!
[piyushksinha89 (1)]: For me shotzcut the AI video editor tool has been fantastic. It creates highlights from multiple videos in secs and also helps create reels from raw landscape videos. A must have
[CertainAd2599 (1)]: Thanks for the list, I'll try Veo3. Any other similar tools like, with free options?
[JustKiddingDude (1)]: Spot the odd one out that is now known and you’ll find the tool that’s being promoted. 

My guess is Saner.ai. The rest are all VERY known tools and notice how this is the only one that has the website mentioned.
[Shawon770 (1)]: I use Kumo, an AI agent that gives weather insights and forecasts through natural language no coding needed. It’s great for planning and decision-making, especially when weather impacts your projects or operations. You just ask, and it provides customized alerts and info without complicated setups. Definitely saves me time and hassle!
[BaconAvocadooo (1)]: is this all for free to use?
[Working-Breadfruit-8 (1)]: Good combo you have right here. 👍
I don't see sanier mentioned often. I used to follow AI tools with social media hype and I ended up subscribing and not using them because they don't work as advertised until I started using a different approach. 
Stumbled on Tipsyai and i was able to get AI tool recommendations that actually work for my business model
[Traditional-Swan-130 (1)]: Since we're talking about useful tools, I found SearchAI Hybrid Search really helpful – it basically combines keyword search with semantic search and brings up much more relevant results.
[martynasn (1)]: I’m a big fan of many of those, especially for handling repetitive or time-sucking tasks.

One newer tool that’s become part of my workflow is Vasara AI. It’s a bit different in that it isn’t just one tool and more like a set of AI assistants, each specialized in a certain area like social media, copywriting, business strategy, etc. I use their Echo assistant to automate social content and I like not having to jump between 5 different tools just to get stuff scheduled or brainstorm ideas.

Otherwise, I’m loyal to ChatGPT for more general idea jams and NotebookLM for summarising and generating "podcasts".
[WiseMoonSigns (1)]: Hey, automating workflows hitting snags? Breaking it into small scripts helps big time.

- Start with no-code tools like Zapier for quick wins.
- Test in stages to avoid bugs.
- Trade-off: Custom code's flexible but steeper learning curve.

AI tools like those on Revid.ai automate demo vids fast. Your focus?
[plzhelpme690 (1)]: These are solid picks, I use a few of these daily too. One more I’d add is Gobii.ai, it’s great for browser-based automation. I’ve been using it to run repetitive workflows like data collection and outreach follow-ups while focusing on creative stuff. Has anyone here tested similar automation tools?
[pogo_iscure (1)]: Nice list, I'd toss MGX into the mix. It's been saving me heaps of time on research and app proto's. The deep research mode is nuts when you need insights from a bunch of sources, and race mode gets you a working version fast without endless tweaks. It sits right between AI agents and no code dev tools.


id: 31db68f74626
title: How to Automate 90% of Your Content Workflow with NotebookLM (Free Method)
source_platform: reddit
author: unknown
published_at: 2026-03-15T01:00:16.169851+00:00
collected_at: 2026-03-15T01:18:49.962436+00:00
scenario_type: 工作流自动化
tools_used: ["NotebookLM", "Perplexity AI", "Gemini", "YouTube"]
novelty: similar
summary:
本文介绍了使用Google的免费工具NotebookLM与Perplexity AI相结合，自动化内容创作工作流的方法。通过上传研究文档、自动生成音频、脚本和多格式内容，创作者可以显著提高效率并实现内容的跨平台复用。

source_url:
https://www.reddit.com/r/AISEOInsider/comments/1q7e6p2/how_to_automate_90_of_your_content_workflow_with/

similar_to_ids:
["fb050128f45f", "46a4d6616c51", "e1859e355e0c", "220851dd1119", "4188cb874081", "97dcab4759c8", "5471379ee4ff", "7ba64475a424"]

raw_content:
How to Automate 90% of Your Content Workflow with NotebookLM (Free Method)

Reddit - The heart of the internetSkip to main content

Go to AISEOInsider
r/AISEOInsider•
JamMasterJulian
# How to Automate 90% of Your Content Workflow with NotebookLM (Free Method)
**AI Content Automation with NotebookLM**is the future of content creation.
Watch the video below:
https://www.youtube.com/watch?v=OMVHdrtzIa4
Want to make money and save time with AI? Get AI Coaching, Support &amp; Courses.
👉Join me in the AI Profit Boardroom:https://juliangoldieai.com/7QCAPR
Most people spend hours researching, summarizing, and formatting.
They open dozens of tabs, re-read the same reports, and lose time they’ll never get back.
Meanwhile, a few smart creators are automating everything.
They use**AI Content Automation with NotebookLM**, a free Google tool, to turn any document into podcasts, videos, study guides, and full blog articles automatically.
No code. No editing. No wasted effort.
Let’s break it down.
# What is AI Content Automation with NotebookLM?
**NotebookLM**is Google’s free AI-powered note and research tool.
You upload PDFs, web pages, or YouTube links, and it analyzes them instantly.
Then it summarizes, explains, and creates new content for you.
But when you combine it with other AI tools, it becomes an automation engine.
That’s the secret behind**AI Content Automation with NotebookLM**.
It’s not just about note-taking.
It’s about scaling content creation without losing quality.
You can:
* Upload research or client docs
* Let AI summarize and build content outlines
* Auto-generate scripts, blog posts, and podcasts
* Repurpose everything across formats in minutes
This is what top creators are doing right now.
# Why AI Content Automation with NotebookLM Works
Google built NotebookLM on Gemini’s reasoning engine.
That means it’s not just summarizing—it’s understanding.
Ask NotebookLM to turn your PDF into a podcast, and it produces two realistic AI voices that discuss the content conversationally.
Ask it to summarize your 100-page report, and it highlights every key insight in seconds.
The best part?
It’s**free**.
This means anyone—from students to marketers to agency owners—can automate their content workflow today.
# The 1-Hour AI Content Automation Workflow
Here’s how the full system works using**AI Content Automation with NotebookLM**.
**Step 1: Research with Perplexity AI**
Search your topic using Perplexity.
It finds real-time data and summarizes top sources.
Ask for a blog post or report format.
**Step 2: Import into NotebookLM**
Upload your Perplexity output as a text file or PDF.
NotebookLM reads and structures it instantly.
**Step 3: Generate the Audio Overview**
Click “Audio Overview.”
NotebookLM turns your research into a podcast-style discussion.
It’s like two hosts breaking down your topic conversationally.
**Step 4: Repurpose Automatically**
Use the script to publish a YouTube video, podcast episode, or LinkedIn post.
Export the transcript as blog content.
Everything happens automatically.
That’s**AI Content Automation with NotebookLM**in action.
What used to take days now happens in under an hour.
# Real Example: From Research to 10 Pieces of Content
Here’s how I used this myself.
I researched “best AI automation tools in 2025” using Perplexity AI.
Then I uploaded the results to NotebookLM.
It created:
* A podcast with two AI hosts discussing automation
* A 10-point blog summary
* A full research report with citations
* A visual presentation deck
* A video outline
From one input, I got 10 outputs.
That’s the entire philosophy behind**AI Content Automation with NotebookLM**.
You create once and multiply results everywhere.
# New Upgrades That Change Everything
NotebookLM recently integrated with**Gemini 3**.
Now it supports up to 300 sources per notebook and creates videos, quizzes, mind maps, and presentations directly from your uploads.
That means:
* You can upload your entire content library
* Auto-generate visual assets
* Build a course or training program in minutes
AI Content Automation with NotebookLM isn’t theory anymore.
It’s happening right now.
# How Businesses Use This to Scale
Agencies are using**AI Content Automation with NotebookLM**to produce training documents, onboarding materials, and video scripts.
Coaches are uploading their course outlines and generating flashcards, quizzes, and certification programs.
Writers are turning one long-form article into podcasts, social posts, and full YouTube scripts.
If you’re a business owner, you can:
* Build SOPs faster
* Create marketing assets automatically
* Summarize team documents
* Train new hires in hours, not days
That’s real leverage.
# The Power of Combining Tools
Perplexity does research.
NotebookLM does creation.
Gemini 3 adds intelligence.
Together, they form the**AI Content Automation with NotebookLM workflow**that replaces entire content teams.
And it’s still free.
This combination saves you hours per week.
It’s not about replacing creativity—it’s about amplifying it.
You focus on insights, and AI handles the structure.
If you want the templates and automations that run this system, check out Julian Goldie’s**FREE AI Success Lab Community**here:https://aisuccesslabjuliangoldie.com/
Inside, you’ll see exactly how creators are using**AI Content Automation with NotebookLM**to automate education, content creation, and client training.
The Success Lab shows real use cases and free workflows anyone can replicate.
# Avoiding Common Mistakes
Here’s what most people get wrong when trying**AI Content Automation with NotebookLM**.
They upload random PDFs and expect perfect content.
NotebookLM isn’t magic—it’s a system.
Here’s what works better:
* Curate quality sources
* Add your unique perspective
* Edit for voice and tone
* Use AI for structure, not creativity
AI helps you work faster, not lazier.
It gives you time to add your expertise.
# Advanced NotebookLM Features You Should Use
1. **Studio Mode**– Create podcasts, quizzes, videos, and slides automatically.
2. **Deep Research**– Pull verified data from the web with citations.
3. **Persona Chat Customization**– Define how the AI responds to you.
4. **Data Tables**– Extract structured insights straight into Google Sheets.
If you combine these features, you can automate nearly your entire content pipeline.
# How AI Content Automation with NotebookLM Saves Time
Traditional research = 10 hours.
NotebookLM workflow = 1 hour.
You go from collecting notes to publishing in a single day.
And the quality often improves.
Because AI doesn’t get tired.
It reads faster.
It summarizes better.
It never misses key details.
You still control the ideas—AI just handles the heavy lifting.
# Who This Is For
**Creators**who want more output with less burnout.
**Entrepreneurs**who need educational content for clients or communities.
**Agencies**who want to systemize research and reports.
**Students**who want faster comprehension.
If you fall into any of those categories, this workflow changes everything.
# Getting Started with AI Content Automation
Here’s the quick setup:
1. Go to notebooklm.google.com
2. Upload your PDFs, Docs, or YouTube links
3. Click “Audio Overview”
4. Generate, review, and export
5. Repurpose across formats
That’s it.
You’re now running a full AI-powered content automation system.
# Final Thoughts
AI Content Automation with NotebookLM isn’t about working harder.
It’s about multiplying your results.
You don’t need to hire 10 people.
You just need one system that scales your voice everywhere.
If you use it right, it becomes your most valuable business asset.
**FAQs**
**Q: Do I need to pay for NotebookLM?**
No. It’s completely free.
**Q: Can I use this for client work?**
Yes. Many agencies already use it to automate deliverables.
**Q: How accurate is the content?**
NotebookLM cites sources, so you can verify everything.
**Q: Where can I get templates to automate this?**
You can access full templates and workflows inside the AI Profit Boardroom, plus free guides inside the AI Success Lab.
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.
Public
Anyone can view, post, and comment to this community
00
Reddit RulesPrivacy PolicyUser AgreementAccessibilityReddit, Inc. ©2026. All rights reserved.
Expand NavigationCollapse Navigation


id: d643c0c3dbe7
source_platform: reddit
author: t2_fr6xu
published_at: 2026-03-16T01:00:11.302053+00:00
collected_at: 2026-03-16T01:00:37.938940+00:00
scenario_type: 商业流程自动化
tools_used: ["OpenClaw", "Google Maps", "LinkedIn", "Email monitoring system", "Web scraping/research tools"]
novelty: similar
similar_to_ids: ["954dc3a3a586", "383475726b14"]
title:
https://www.reddit.com/r/OpenClawUseCases/comments/1rr58wa/i_turned_openclaw_into_a_full_sales_assistant_for.json

summary:
用户用OpenClaw构建了一个完整的销售助手系统，替代了月费500-2000美元的商业工具。系统包括邮件监控、前景研究、个性化外联和会议准备等功能，月成本仅需20-35美元API费用，在本地Mac Mini上运行。

source_url:
https://www.reddit.com/r/OpenClawUseCases/comments/1rr58wa/i_turned_openclaw_into_a_full_sales_assistant_for.json

raw_content:
https://www.reddit.com/r/OpenClawUseCases/comments/1rr58wa/i_turned_openclaw_into_a_full_sales_assistant_for.json

I spent the last few months building sales systems for small businesses. most of them were paying $500-2000/month for tools like Apollo, Outreach, etc. I wanted to see if I could replicate the core stuff with OpenClaw.

Turns out you can get pretty far.

Here's what I set up and what it actually does:

**Inbox monitoring.** OpenClaw watches my email and flags anything that looks like a warm lead or a reply worth jumping on. no more scanning through 200 emails in the morning.

**Prospect research.** I describe who I'm looking for in plain english. "HVAC companies in the chicago suburbs with a website and phone number." it pulls from google maps, cleans the data, and gives me a list I can actually call.

**Personalized outreach.** It takes the prospect list and writes first-touch emails based on what it finds on their website and linkedin. not the generic "I noticed your company" stuff. actual references to what they do.

**Meeting prep.** Before a call it pulls together everything it can find on the person and company. linkedin, recent news, job postings, tech stack. takes 30 seconds instead of 15 minutes.

The whole thing runs on a mac mini I leave on at home. total cost is basically the API usage which comes out to $20-35/month depending on volume.

A few things I learned the hard way:

1. Skills are everything. don't try to prompt your way through complex workflows. find the right skills or write your own. the difference is night and day.
2. Start with one workflow and get it solid before adding more. I tried to set up everything at once and it was a mess.
3. The outreach quality depends heavily on how well you define your ICP upfront. garbage in, garbage out.
4. Security matters. lock down your API keys, use environment variables, don't give it access to folders it doesn't need.

I wrote up the full setup with configs and step by step instructions if anyone wants to go deeper. happy to answer questions here too.


id: 8d1fb8062ab4
source_platform: reddit
author: unknown
published_at: 2026-03-16T01:00:11.302057+00:00
collected_at: 2026-03-16T01:00:48.413408+00:00
scenario_type: 工作流自动化
novelty: similar
similar_to_ids: ["2587854ae526", "9d622833f3fc", "93d2c2bcd5d9", "fb050128f45f", "7e9bc69a52f6", "034f0f8b6fff"]
title:
11 OpenClaw Hacks That Completely Changed How I Use My Agent (Going from 1% to 100% of its value) : r/OpenClawUseCases

summary:
本文介绍了11个OpenClaw代理优化技巧，涵盖模型选择、本地部署、多平台集成、逆向提示等策略，通过任务并行化和自动化工作流显著提升代理的实用价值。重点强调本地部署的优势和将所有任务流经代理进行优化的工作习惯，为用户从1%提升到100%的代理价值。

source_url:
https://www.reddit.com/r/OpenClawUseCases/comments/1rbmrup/11_openclaw_hacks_that_completely_changed_how_i/

tools_used:
["OpenClaw", "Opus", "Codex", "Minimax 2.5", "Qwen 3.5", "Telegram", "Discord", "NextJS", "Claude Code"]

raw_content:
11 OpenClaw Hacks That Completely Changed How I Use My Agent (Going from 1% to 100% of its value) : r/OpenClawUseCases

11 OpenClaw Hacks That Completely Changed How I Use My Agent (Going from 1% to 100% of its value) : r/OpenClawUseCases Skip to main content 11 OpenClaw Hacks That Completely Changed How I Use My Agent (Going from 1% to 100% of its value) : r/OpenClawUseCases

Go to OpenClawUseCases

r/OpenClawUseCases 1d ago

Forsaken-Kale-3175

# 11 OpenClaw Hacks That Completely Changed How I Use My Agent (Going from 1% to 100% of its value)

Most people are using OpenClaw like a fancy ChatGPT wrapper. That's only tapping into 1% of its actual power. Here are 11 hacks — remixed from a viral thread by u/AlexFinn— that I've personally tested and want to share with this community.

---

**1. Use Opus for the brain, specialized models for every task**

Stop using one model for everything. Use Codex for coding, Minimax 2.5 for research, Qwen 3.5 for creative writing. You save money AND parallelize tasks. Just tell your Claw which model to use for which job.

**2. Host on a local device — not a VPS**

Local = your agent works *with* you, in your environment, with instant access to your files. VPS is like hiring someone who works in a different timezone. On local, you can airdrop a video, have your Claw auto-detect it, transcribe, translate to 10 languages, and generate a thumbnail — all automatically. Nearly impossible on VPS.

**3. Telegram for quick tasks, Discord for deep work**

Telegram is fastest for rapid back-and-forth. Discord lets you build multi-channel workflows where your main agent spins up subagents in separate channels — massively parallel output.

**4. Use Reverse Prompting (this one is a game-changer)**

Instead of always telling your Claw what to do, ask *it* what you should do next:

> "Based on what you know about me and my goals, what's the next best task we should work on?"

You'll be surprised how smart it gets. Use this whenever your bot is idle.

**5. Let OpenClaw vibe code for you**

Don't use Claude Code or Codex directly. Just tell your Claw what to build — it will use Codex CLI to build it itself. Way easier.

**6. Build your own Mission Control**

Have your Claw build a custom NextJS dashboard as a home for your tooling. Use this prompt:

> "Build me a Mission Control in NextJS. Then build 3 tools you think will improve our workflows."

You'll have custom automation tools built to your exact needs in minutes.

**7. Run EVERY computer task through your Claw first**

Anything you're about to do — writing docs, building a feature, researching — ask your Claw how it can do it better or faster first. This habit compounds over time and is probably the highest-leverage change you can make.

**8. Start cheap, scale only if needed**

You don't need a Mac Studio on day one. Start with an old laptop. Learn the workflows first. Only upgrade hardware when you've outgrown what you have.

**9. Don't give it Gmail access**

The email automations aren't worth the prompt injection risk. Keeping your inbox out of your agent's reach is just good security hygiene.

**10. Don't give it its own X/Twitter account**

X is actively cracking down on bot API usage right now. Even legit third-party tools are getting flagged. Not worth the risk.

**11. Just have fun and experiment**

The best use cases in this subreddit came from people tinkering without a clear goal. Give yourself permission to play. This is the most interesting technology most of us will ever get to use in our lifetimes.

---

Original article by Alex Finn: https://x.com/AlexFinn/status/2025302022749389282(445K views)

What hacks have YOU discovered that aren't on this list? Drop them below — let's build the definitive OpenClaw optimization guide together.

Read more

Share

---

Eyye95

20h ago

Great insights 👍🏼

1

LemonData_Official

15h ago

Great advice, I use the 1st tip, my X operation agent's one-day cost down from $20-30 to $0.5, thought it would be cost-saving, never thought it will be so much.

1

Version_Impressive

13h ago

Coding. Research and creative writing can be done on anthropic’s and openai’s native os apps. It’s not worth it. Number 4 is so stupid.

1

squachek

11h ago

How are hallucination cascades affecting things?

1

ndxzze

6h ago

Is it okay to give it read and draft access to Gmail? Or will it still be probe to injection? Thinking about using Zapier MCP

1

NeophyteBuilder

5h ago

Read is where it is susceptible to injection

1

Continue this thread

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


id: 761de79bdf32
title: Show HN: What if your synthesizer was powered by APL (or a dumb K clone)?
source_url: https://octetta.github.io/k-synth/
source_platform: hackernews
author: octetta
published_at: 2026-03-15T12:58:13+00:00
collected_at: 2026-03-16T01:00:59.026590+00:00
scenario_type: 代码生成与审查
tools_used: ["APL", "K语言", "WASM", "Web Audio API", "AI代码生成"]
novelty: similar
similar_to_ids: ["0e4296f0f076", "c308aabe6a31", "9430b10f8840", "845dff761b29"]
summary:
作者开发了k-synth，一个受APL启发的极简数组语言DSL，用于在Web浏览器中快速生成音频波形。项目利用AI辅助开发了解析器和Web工具链，展示了如何用函数式编程范式简化音频合成的表达方式，适合作为DAW的补充工具进行样本生成。

raw_content:
Show HN: What if your synthesizer was powered by APL (or a dumb K clone)?

I built k-synth as an experiment to see if a minimalist, K-inspired array language could make sketching waveforms faster and more intuitive than traditional code. I’ve put together a web-based toolkit so you can try the syntax directly in the browser without having to touch a compiler:<p>Live Toolkit: <a href="https:&#x2F;&#x2F;octetta.github.io&#x2F;k-synth&#x2F;" rel="nofollow">https:&#x2F;&#x2F;octetta.github.io&#x2F;k-synth&#x2F;</a><p>If you visit the page, here is a quick path to an audio payoff:<p>- Click &quot;patches&quot; and choose dm-bell.ks.<p>- Click &quot;run&quot;—the notebook area will update. Click the waveform to hear the result.<p>- Click the &quot;-&gt;0&quot; button below the waveform to copy it into slot 0 at the top (slots are also clickable).<p>- Click &quot;pads&quot; in the entry area to show a performance grid.<p>- Click &quot;melodic&quot; to play slot 0&#x27;s sample at different intervals across the grid.<p>The &#x27;Weird&#x27; Stack:<p>- The Language: A simplified, right-associative array language (e.g., s for sine, p for pi).<p>- The Web Toolkit: Built using WASM and Web Audio for live-coding samples.<p>- AI Pair-Programming: I used AI agents to bootstrap the parser and web boilerplate, which let me vet the language design in weeks rather than months.<p>The Goal: This isn&#x27;t meant to replace a DAW. It’s a compact way to generate samples for larger projects. It’s currently in a &quot;will-it-blend&quot; state. I’m looking for feedback from the array language and DSP communities—specifically on the operator choices and the right-to-left evaluation logic.<p>Source (MIT): <a href="https:&#x2F;&#x2F;github.com&#x2F;octetta&#x2F;k-synth" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;octetta&#x2F;k-synth</a>


id: 628765deddd5
source_platform: reddit
author: t2_9kiq0vum
published_at: 2026-03-16T01:00:11.302060+00:00
collected_at: 2026-03-16T01:01:09.879189+00:00
scenario_type: 工作流自动化
novelty: similar
similar_to_ids: ["87a318a4984d", "9d8451ba2dcd", "2587854ae526", "bea33498d6bd"]
title:
https://www.reddit.com/r/openclaw/comments/1ru6g7v/i_built_a_plugandplay_skill_library_for_openclaw.json

summary:
用户为OpenClaw框架开发了一个包含31个即插即用技能的超级库，解决了生产环境中的关键痛点：安全防护（提示注入和危险操作检测）、成本控制（支出断路器和Cron优化）以及可靠性保证（工作流保护和状态完整性校验）。该解决方案通过自动化守卫机制和人机循环，显著提升了代理的安全性（92%对抗防御率）和成本效益，是解决OpenClaw日常运维问题的实用工程方案。

source_url:
https://www.reddit.com/r/openclaw/comments/1ru6g7v/i_built_a_plugandplay_skill_library_for_openclaw.json

tools_used:
["OpenClaw", "prompt-injection-guard", "dangerous-action-guard", "workspace-integrity-guardian", "spend-circuit-breaker", "cron-hygiene", "loop-circuit-breaker", "GitHub", "git"]

raw_content:
https://www.reddit.com/r/openclaw/comments/1ru6g7v/i_built_a_plugandplay_skill_library_for_openclaw.json

Been running OpenClaw daily for a few months and kept hitting the same walls everyone else complains about: runaway API costs, agents executing destructive actions without asking, context evaporating when I switched from Telegram to my desktop, \[SOUL.md\] getting silently mangled mid-session.

So I built **openclaw-superpowers** — a library of 31 drop-in skills you can install in one command. Sharing it here because most of these came directly from threads in this sub and GitHub issues.

**The install:**

 git clone https://github.com/ArchieIndian/openclaw-superpowers ~/.openclaw/extensions/superpowers
 cd ~/.openclaw/extensions/superpowers &amp;&amp; ./install.sh
 openclaw gateway restart

That's it. \[`install.sh`\] handles state directories, cron registration, everything.

**What's in it - the highlights:**

**Security (the stuff that actually scared me)**

* `prompt-injection-guard` — Snyk found 36% of ClawHub skills have injection payloads baked in. But even if your installed skills are clean, your agent is still reading emails, web pages, and scraped docs every day. This skill scans external content at runtime for 6 injection signal types and blocks on 2+ hits. The existing "vet before install" advice only catches half the attack surface.
* `dangerous-action-guard` — Research puts OpenClaw's native defense rate against adversarial scenarios at 17%. Adding a human-in-the-loop gate for irreversible actions (git force-push, file deletion, email sends, API writes) raises it to 92%. 5-minute expiry window so stale approvals don't haunt you. Full audit trail.
* `workspace-integrity-guardian` — SOUL.md, AGENTS.md, MEMORY.md are your agent's entire identity. They can be silently overwritten by the agent itself or a bad skill. This hashes them on first run and checks weekly. If your SOUL.md gets fully replaced, you get a diff and a one-command restore. The docs literally say "a compromised SOUL.md means a permanently hijacked agent that survives restarts."

**Cost (the bills I was not expecting)**

* `spend-circuit-breaker` — There's no native OpenClaw budget cap. Set a monthly limit (`python3` \[`check.py`\] `--set-budget 50`), get alerts at 50% and 75%, and at 100% it automatically pauses all non-essential cron automations. Reads your session JSONL logs to estimate spend from actual token counts. Distinct from context-budget-guard which tracks tokens — this tracks dollars.
* `cron-hygiene` — Crons running in main session mode re-send your entire conversation history on every wakeup. A cron every 15 minutes in main mode vs isolated mode is roughly a 10x cost difference. This runs weekly and flags your expensive crons with remediation steps.

**Reliability (the silent failures)**

* `loop-circuit-breaker` — OpenClaw retries a missing-parameter error the exact same way it retries a rate limit. This means a `read({})` call with no path will retry indefinitely, silently draining context. This skill tracks normalized (tool, args, error) signatures per session and trips after 2 identical failures. Exit code 2 = trip. The agent knows to stop.
* `workspace-integrity-guardian` also covers this — if a skill corrupts a config file during a bad execution, you'll know Sunday morning.

**The DX stuff (quality of life)**

* `channel-context-bridge` — Every time I moved from Telegram to my laptop I had to re-explain what we were doing. This writes a compact "resumé card" at session end: what we were working on, key decisions made, next actions. New sessions check for a recent card and inject it as a primer. The user just continues talking.
* `project-onboarding` — Crawls a new codebase, detects the stack, build commands, test framework, CI config, and key directories. Generates a \[`PROJECT.md`\] template. You validate it once, the agent loads it automatically on every future session in that directory. Stops the hallucinated conventions problem cold.
* `multi-agent-coordinator` — If you're running 3+ agents in parallel there's no native health monitoring. This lives in your orchestrator agent and tracks each sub-agent's last-seen timestamp. Detects timeouts, flags contradicting parallel outputs before you merge them.
* `fact-check-before-trust` — `verification-before-completion` checks "did the agent do the task?" This checks "is what the agent said *true*?" Scores each factual claim (High/Medium/Low confidence), re-fetches low-confidence ones, and surfaces contradictions before you act on them. Documented case that prompted this: an agent reported a £716 fee as £70,000.

**The architecture**

All 31 skills are plain \[`SKILL.md`\] files with YAML frontmatter. Nothing magical. The cron-scheduled ones have a `cron:` field that \[`install.sh`\] reads to register with `openclaw cron add`. Stateful skills commit a `STATE_SCHEMA.yaml` — the actual runtime state lives locally at `~/.openclaw/skill-state/&lt;skill-name&gt;/state.yaml`, never committed.

Each skill that ships with a companion script (`guard.py`, \[`check.py`\], \[`audit.py`\], etc.) can be run standalone from the terminal — they don't require the agent to be running. Useful for debugging and one-off checks.

**What I'd love from this community:**

1. If there are skills in here that overlap with something you've already built — tell me, happy to merge
2. The `skills/community/` directory is explicitly for agent-written contributions. If your agent writes a good skill, PR it
3. Issue reports on the 10 new skills especially — they haven't had real-world soak time yet

*Built this because I was tired of losing context, racking up surprise bills, and explaining to my agent why it probably shouldn't have force-pushed to main. Hope it saves someone else the same headaches.*


id: 69a2462f0bc5
title: Show HN: Open-source playground to red-team AI agents with exploits published
source_url: https://github.com/fabraix/playground
source_platform: hackernews
author: zachdotai
published_at: 2026-03-15T22:29:46+00:00
collected_at: 2026-03-16T01:01:31.314366+00:00
scenario_type: 代码生成与审查
tools_used: ["AI agent runtime", "security guardrails", "tool calling framework", "conversation logging"]
novelty: new
similar_to_ids: []
summary:
这是一个用于测试和红队AI代理安全性的开源平台,通过发布实时agent challenges和完整的漏洞利用记录来帮助识别AI系统中的安全缺陷。该项目提供了一个通用AI代理框架和防护机制,用于发现和记录agent在工具调用、指令遵循等方面的漏洞,推进AI系统的安全部署。

raw_content:
Show HN: Open-source playground to red-team AI agents with exploits published

We build runtime security for AI agents. The playground started as an internal tool that we used to test our own guardrails. But we kept finding the same types of vulnerabilities because we think about attacks a certain way. At some point you need people who don&#x27;t think like you.<p>So we open-sourced it. Each challenge is a live agent with real tools and a published system prompt. Whenever a challenge is over, the full winning conversation transcript and guardrail logs get documented publicly.<p>Building the general-purpose agent itself was probably the most fun part. Getting it to reliably use tools, stay in character, and follow instructions while still being useful is harder than it sounds. That alone reminded us how early we all are in understanding and deploying these systems at scale.<p>First challenge was to get an agent to call a tool it&#x27;s been told to never call.<p>Someone got through in around 60 seconds without ever asking for the secret directly (which taught us a lot).<p>Next challenge is focused on data exfiltration with harder defences: <a href="https:&#x2F;&#x2F;playground.fabraix.com" rel="nofollow">https:&#x2F;&#x2F;playground.fabraix.com</a>


id: a4713fb9eb43
title: 3 weeks with OpenClaw as daily driver - what worked, what broke : r/LocalLLaMA
source_platform: reddit
author: unknown
published_at: 2026-03-16T01:00:11.302086+00:00
collected_at: 2026-03-16T01:01:40.932545+00:00
scenario_type: 工作流自动化
tools_used: ["OpenClaw", "Claude API", "AWS VPS", "WhatsApp", "Telegram", "Cron jobs"]
novelty: similar
similar_to_ids: ["628765deddd5", "8d1fb8062ab4", "2587854ae526", "93d2c2bcd5d9"]
summary:
用户分享了将OpenClaw作为日常驱动工具3周的实践经验，包括多智能体架构、内存管理、内容质量控制等工作流设计，以及遇到的故障（时间戳计算错误、消息传递问题等）及其解决方案。这是一个成熟的本地AI工作流自动化案例，具有高度的实际应用价值和清晰的系统设计模式。

source_url:
https://www.reddit.com/r/LocalLLaMA/comments/1r3ro5h/3_weeks_with_openclaw_as_daily_driver_what_worked/

raw_content:
3 weeks with OpenClaw as daily driver - what worked, what broke : r/LocalLLaMA

3 weeks with OpenClaw as daily driver - what worked, what broke : r/LocalLLaMA Skip to main content 3 weeks with OpenClaw as daily driver - what worked, what broke : r/LocalLLaMA

Go to LocalLLaMA

r/LocalLLaMA 28d ago

justserg

# 3 weeks with OpenClaw as daily driver - what worked, what broke

Been running OpenClaw for about 3 weeks now as my daily driver. Figured I'd share what actually works, what broke, and the patterns that emerged.

Setup:

AWS VPS (t3.medium, 40GB disk)

Claude via Anthropic API (mix of Haiku for cheap tasks, Sonnet and Opus for complex stuff)

WhatsApp + Telegram as interfaces

~20 cron jobs running various automations

What's working well:

1. Multi-agent architecture

I run 5 specialized sub-agents instead of one generalist:

Writer (content generation)

Editor (quality control with scoring rubric)

Researcher (market analysis, web searches)

Coder (implementation tasks)

Pipeline manager (monitors the content queue)

The key insight: spawning isolated sessions for complex tasks works way better than cramming everything into one context. The researcher can spend 10 minutes digging without polluting my main conversation.

2. Memory patterns

Settled on a two-tier approach:

Daily logs (memory/YYYY-MM-DD.md) - raw notes, decisions, what happened

Curated long-term memory (MEMORY.md) - distilled lessons, key context

A nightly cron job reviews daily logs and extracts anything worth keeping. This prevents MEMORY.md from becoming a junk drawer.

3. Content pipeline with quality gates

Writer generates drafts → Editor scores them (100-point rubric) → anything below 70 gets rejected or sent back for revision.

Current rejection rate: ~40%. That sounds bad but it's actually healthy - means the quality bar is real.

What broke (and fixes):

1. The "Dory Problem"

Cron jobs have no memory of what happened in main session. I'd tell the agent "cancel that follow-up, it's handled" and then 2 days later a scheduled cron would fire anyway because it was set before the cancellation.

Fix: Any cron that takes external action must check a DECISIONS.md file first. If there's a recent override, abort.

2. Cron timestamp calculation

Early on I let the agent calculate Unix timestamps mentally. It wrote "2025" instead of "2026" twice, creating past timestamps that fired immediately. Sent messages to people at wrong times.

Fix: Never calculate timestamps manually. Always run date -d "YYYY-MM-DD HH:MM:SS UTC" +%s%3N first.

3. The deliver:true leak

OpenClaw cron jobs have a deliver option. If true, it sends the full agent output to your chat. Problem: that includes internal reasoning like "Now I'll check the calendar and then send a message..."

Had several embarrassing moments where my WhatsApp received the agent's internal monologue instead of a clean summary.

Fix: Always use deliver:false and have the agent explicitly use the message tool for output.

4. Sub-agent context contamination

Sub-agents can load cached context files. Had a situation where a sub-agent flagged "credentials expired!" based on stale MEMORY.md content, even though I'd already fixed it in main session.

Fix: Sub-agents for verification tasks should re-check live state, not trust cached memory.

Numbers after 3 weeks:

~20 active cron jobs

~15 daily logs

5 specialized sub-agents

Haiku handles ~80% of automated tasks (10-20x cheaper)

Sonnet for anything requiring judgment or complex reasoning, Opus only for critical tasks.

Content pipeline produced ~30 drafts, ~18 approved

Biggest lesson:

Automation without guardrails creates more problems than it solves. Every cron job that messages someone or takes external action needs:

A pre-flight check (is this still relevant?)

Output sanitization (no internal reasoning leaking)

A way to abort if context changed

The goal is reliable automation, not maximum automation.

---

Happy to answer questions about specific setups.

Read more

Share

---

• Promoted

A bright side to market volatility? Yep, we’ve got one. Wealthfront uses Tax-Loss Harvesting to turn dips into potential tax savings—automatically. Here’s how it helps you keep more of your money long term.

---

truth_is_power

28d ago

what is the content for?

7

Daemontatox

28d ago

For wasting your time

16

Continue this thread

son12

24d ago

how much did it cost? do you pay-as-you-go? even though claude performs best - especially opus 4.6, i blow through my usage in 30 mins on the pro plan. i've gotten decent results with minimax 2.5 api after initial setup with opus. now i'm thinking of buying an m3 ultra to run locally instead of sending prompts to china.

4

Fusseldieb

20d ago

The real questions

1

Pinklloyd68

18d ago

I would like to know costs but what makes you think prompts are going to china?

1

son12

15d ago

minimax is a chinese company

1

5 more replies

Continue this thread Continue this thread Continue this thread

Relative-Tourist8475

22d ago

OP says it will respond to any question. 0 questions answered. :)

2

• 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.

o0genesis0o

28d ago

You can write (or vibe code) python to run inside the cron job deterministically against your anthropic api, and you will save more time and money and have better results than letting the agent run amok to try to get things done. And your computer would be safer too.

2

ceo_of_banana

28d ago

I assumed you were running a local model on a vps because of the subreddit which had me intrigued. still interesting as i use claw too. My question would be, how often do you start a new main session? Do you use /compact? Also, could you explain what the pipeline manager does and how you use? Thanks

1

Pinklloyd68

18d ago

Good question, I've been building basically a react dashboard to interact with claw to hopefully manage the workflows I build. I can see his issue and understand where he's going. I'm concentrating on building some structure and insight into the agents ability to understand and control workflows. I love the ability to connect to api's, manage content generation and seek to create a similar rating system to creating content that's relevant, optimized and creative.

1

Continue this thread

Glittering_Editor337

27d ago

The gradual degradation pattern you are describing is classic OpenClaw without maintenance routines. It accumulates session transcripts, cached states, and stale websocket connections until things start breaking silently.

What fixed it for me: cron jobs that handle cleanup automatically. Daily log rotation, session cache pruning when memory usage crosses a threshold, and a self-healing script that restarts services when they go unresponsive. Also bumped WatchdogSec to 1800 because the default timeout was killing long-running tool chains.

The 3-week timeline suggests you are hitting transcript bloat more than anything architectural. Check your session transcript sizes, they can balloon past 50MB if you are running agents actively. Archiving old transcripts made a huge difference in my setup.

What specific breaking points did you hit? Memory leaks, token exhaustion, or skill conflicts? That would narrow down whether you need better cleanup or a config change.

1

Pinklloyd68

18d ago

I've been considering connecting an agent to reddit for deep conversation and research. Finding informative responses is where the true wisdom is. This makes sense. I was wondering what type of agents you run and how you deal with content pipelines?

1

Continue this thread

Relative-Tourist8475

22d ago

u/justserg do you have a git repo with your openclaw config? I can't get close to any of those results.

1

Commercial_User_576

21d ago

just to confirm, you are talking about subagents (from 1 agent), not separate multi-agents?

1

---

## View Post in

Français

हिन्दी

Português (Brasil)

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

Expand Navigation Collapse Navigation


id: eee0462e22ad
source_platform: reddit
author: unknown
published_at: 2026-03-16T01:00:12.550346+00:00
collected_at: 2026-03-16T01:02:06.608467+00:00
scenario_type: 代码生成与审查
novelty: similar
similar_to_ids: ["c308aabe6a31", "517aee42d849", "1f770ae13aa5", "5b6f4e63a641", "d828a3a68478"]
title:
Your AI coding assistant is mass-producing code that already exists as polished tools : r/vibecoding

summary:
讨论AI代码助手倾向于从零开始生成冗长代码而非推荐现有工具和服务的问题。作者提出使用MCP服务器来帮助AI助手在编码前检查现有解决方案，以减少代码生成、降低token消耗并提高生产效率。这反映了在构建与采购决策中如何更智能地利用AI的核心问题。

source_url:
https://www.reddit.com/r/vibecoding/comments/1rbxflu/your_ai_coding_assistant_is_massproducing_code/

tools_used:
["AI coding assistants", "MCP servers", "Auth providers", "Payment tools", "Email marketing services"]

raw_content:
Your AI coding assistant is mass-producing code that already exists as polished tools : r/vibecoding

Your AI coding assistant is mass-producing code that already exists as polished tools : r/vibecoding Skip to main content Your AI coding assistant is mass-producing code that already exists as polished tools : r/vibecoding

Go to vibecoding

r/vibecoding 2d ago

indiestack

# Your AI coding assistant is mass-producing code that already exists as polished tools

Every time you ask an AI coding assistant to "build auth" or "add payments" or "set up email marketing," it happily generates 40-80k tokens of code. Authentication alone can be 60+ files when you include routes, middleware, password reset, email verification, session management...

Meanwhile there are indie tools that do all of this out of the box for $5-15/mo with battle-tested code and actual support.

I've been thinking about this a lot — the default behavior of every AI coding assistant is to generate code from scratch. None of them check whether a maintained tool already solves the problem. It's like having a contractor who builds custom furniture for every room instead of checking if IKEA has what you need.

The math is wild:

Vibe-coding an invoicing system: ~50k tokens + hours of debugging

Integrating an existing tool's API: ~2k tokens + it actually works in production

MCP servers seem like the right solution here — you can give your assistant access to a tool directory so it checks what exists before writing boilerplate. I've been experimenting with this approach and it's cut my token usage significantly.

Anyone else feel like they're burning tokens on code that shouldn't need to exist? How do you decide build vs. buy when vibe coding?

Read more

Share

---

• Promoted

Stop babysitting terminals. Manage a team of agents from a doc. Try Tonkotsu FREE.

---

realquidos

2d ago

If you tell it to "build auth" it will do that. If you ask it to "research and compare different auth providers", it will do that instead.

47

zenware

1d ago

But if you tell a human SWE/team to build auth, they might conclude that it’s a good idea to see if an existing service would be suitable.

5

3 more replies

Continue this thread

elchemy

2d ago

All code has been written before just not in complete forms

32

bespokeagent

2d ago

An LLM will 100% do this without an MCP if you ask it for solutions including implementing or using OSS, or SaaS.

It will even pro/con it for you if you ask.

There are too many of these posts, "I didn't ask AI for X, AI didn't give me X. AI is broke!"

10

5 more replies

Continue this thread

BreathingFuck

2d ago

People don’t even realize this when their AI does it. It’s why they so proudly end up with 1 million lines of code for a todo app.

26

FreeYogurtcloset6959

2d ago

Some people even think that a lot of generated code means huge productivity.

6

gk_instakilogram

2d ago

yeah people who have no idea about what it takes to build software.

Good developers write code, great developers delete code. It is going to be a big business to clean up all of this slop being generated now.

4

4 more replies

Continue this thread 2 more replies

Continue this thread 8 more replies

Continue this thread

ThisGuyCrohns

2d ago

I do not want to pay $5-10m for all this shit. Enough of the fractional services. Shit needs to stop. Generated code needs to avoid duplication but it can build what you need if you know what you’re doing.

14

5 more replies

Continue this thread

lm913

2d ago

I think it's experience and awareness of existing solutions that does the trick.

4

Tr1LL_B1LL

2d ago

That’s a lot of it. When i started, i didn’t know anything, just that it would be cool to learn to code. So i started asking questions and went from there. Many of us are just unaware of our options because we don’t even know to ask lol

2

lm913

2d ago

I think that's it. Not everything needs to be solved, only the things that aren't already.

3

Continue this thread

indiestack

1d ago

100%. the people getting the best results from AI are the ones who already know what good code looks like. AI just makes them faster, it doesn't replace the judgement

2

Continue this thread

• Promoted

Turn your app idea into something real with Base44. Start building today.

caldazar24

2d ago

? My agents will definitely suggest third party tools for payments and emails, and open-source libraries for auth. What exactly are you using?

4

Crowley-Barns

2d ago

I’d be very impressed if one figured out how to take payments without a third-party tool lol.

3

2 more replies

Continue this thread

telcoman

2d ago

What are you using?

2

3 more replies

Continue this thread Continue this thread

Terrible_Beat_6109

2d ago

It's just copy pasting code from GitHub.

4

5 more replies

Continue this thread

abbh62

2d ago

So 50k tokens, a little debugging and I don’t pay 5-15/mo? Ie I save up to like 180/yr.

4

3 more replies

Continue this thread

Phobic-window

2d ago

IMO you’ve missed the point here. Rather than having 200 tools and subscriptions to keep track of, it’s now trivial to build that tool yourself, and not have to pay for it again.

At least for experienced devs this is sustainable. AI has just devalued tools of convenience

8

Interesting-Agency-1

2d ago

And you own it outright and can change it or build out more features exactly how you like.

6

Abject-Kitchen3198

2d ago

Experienced devs are the first to consider buying instead of building. I was happy to build my own ORM in my first years. No way I'm doing something equivalent today, with or without LLM.

3

thedevelopergreg

2d ago

As with most things the truth is somewhere in the middle.

There are many existing tools that can just be replaced in your own code via AI.

But there are some features that are probably best left to experts for that feature. Best examples of this are probably auth and payment processing.

2

indiestack

1d ago

fair point for experienced devs but most people using AI to code aren't experienced devs ÔÇö thats kind of the whole point of vibecoding. for them building their own auth or payment system is a landmine. the convenience tools exist for a reason even if they're overpriced

2

4 more replies

Continue this thread

• Promoted

🚀 Introducing Knack 2.0 — our new AI app builder is here. Our new AI app builder allows anyone to create and refine real, production-ready apps in moments through simple AI prompts. No setup. No code. Just conversation.

Collapse video player

VincentJenei

2d ago

This post itself is AI slop.

3

1 more reply

Continue this thread

Michaeli_Starky

2d ago

Yes. No. Maybe.

2

2 more replies

Continue this thread

190531085100

2d ago

Everything has already been coded. But not by everyone.

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: ffac4b8146c2
source_platform: reddit
author: t2_1vq9fi0yxs
published_at: 2026-03-16T01:00:12.550361+00:00
collected_at: 2026-03-16T01:02:36.318092+00:00
scenario_type: 个人知识管理
tools_used: ["Claude Code", "OpenCode", "Cursor", "Gemini CLI", "Go", "SQLite", "FTS5"]
novelty: similar
similar_to_ids: ["ee3a283cf9be", "e70af22d37d1", "58fd428d6d0d"]
title:
https://www.reddit.com/r/vibecoding/comments/1r92tye/i_indexed_89037_ai_coding_messages_heres_what_i.json

summary:
用户构建了mnemo工具，一个Go CLI应用，用于整合来自12个不同AI编码工具（Claude Code、OpenCode、Cursor等）的89,037条编程决策日志，并通过SQLite+FTS5建立本地全文搜索索引。该方案完全本地化、无需云端，支持跨工具决策追踪和上下文感知搜索，与Claude Code深度集成实现历史记忆功能。

source_url:
https://www.reddit.com/r/vibecoding/comments/1r92tye/i_indexed_89037_ai_coding_messages_heres_what_i.json

raw_content:
https://www.reddit.com/r/vibecoding/comments/1r92tye/i_indexed_89037_ai_coding_messages_heres_what_i.json

I hit a wall with 89,037 AI coding messages spread across 12 tools. No way to dig through them all. Not just chat logs - my decision journal. Every "why JWT over sessions," every "fixed that race condition at 2am," every trade-off I swallowed. 

Scattered in: Claude Code's JSONL files, OpenCode's JSON logs, Cursor's SQLite dumps, Gemini CLI's JSON outputs... all different formats. 



So I built `mnemo`. No product launch - just a way to track my own decisions.

**What's in it?** A Go CLI that:

1. Auto-detects your AI tools

2. Parses their native formats (12 adapters done)

3. Indexes everything into SQLite + FTS5

4. Lets you search across the whole mess

`mnemo index # Scan and index everything`

`mnemo search "authentication flow"`

`mnemo context my-project`



**Key choices:** 

\- Pure Go SQLite (modernc.org/sqlite) - no CGO, compiles everywhere. WAL mode for concurrent reads.

\- Single-writer rule to avoid database locks. No setup - works on first run. All local - data never leaves your machine.

\- Search ranking isn't just BM25: FinalScore = (BM25 + densityBonus + userBonus) x temporalDecay. Groups results by session, weights recent stuff higher, prioritizes what YOU asked over AI answers.

**Claude Code hook:** Tapped into UserPromptSubmit - my AI now pulls context from past sessions. We talked about X last week? It remembers.

**Result:** 89k messages, fully searchable, \~0.8s per query. My AI coding sessions are now my decision journal.

**GitHub:** https://github.com/Pilan-AI/mnemo

Built in public, no cloud, all local.

If you're drowning in decision journal sprawl across tools, what's your setup?

P.S. Open source. Brew tap available. PRs welcome if your favorite AI tool isn't supported yet.

Onboarding process


id: 2f043903e426
source_platform: reddit
author: t2_2nzuh
published_at: 2026-03-16T01:00:13.999539+00:00
collected_at: 2026-03-16T01:02:44.911481+00:00
scenario_type: 商业流程自动化
tools_used: ["Claude Code", "TextForge", "Pipedrive", "Google Cloud API", "MCP server", "HTTP API"]
novelty: similar
similar_to_ids: ["d643c0c3dbe7", "954dc3a3a586"]
title:
https://www.reddit.com/r/ClaudeAI/comments/1rrh2ef/i_used_claude_code_to_write_a_tool_to_automate_my.json

summary:
用户利用Claude Code构建了TextForge工具来自动化其B2B软件服务公司的邮件流程，每周节省8-10小时。系统通过审批门槛确保Claude无法未经授权发送邮件，实现了类似代码审查的电子邮件工作流，显著改善了业务指标。

source_url:
https://www.reddit.com/r/ClaudeAI/comments/1rrh2ef/i_used_claude_code_to_write_a_tool_to_automate_my.json

raw_content:
https://www.reddit.com/r/ClaudeAI/comments/1rrh2ef/i_used_claude_code_to_write_a_tool_to_automate_my.json

TL;DR; I built https://textforge.net/ using Claude Code to help me automate tons of email flows I need to run my business... using Claude Code! TextForge prevents Claude or any other LLM from sending any emails without you approving it first. 

 
I run a small software services company, built around an open source project that I've been maintaining for 10 years or so. We're a small team and I handle sales, our customers' vendor onboarding processes (answering giant security questionnaires, etc), sending red-lined contracts back and forth, and lots of rather random email-driven processes like surveying our customers after we run a training, customer support, accounts receivable etc.

This added up to 8-10 hours of my time per week at least. Most of that work was heavily template driven before anyway and required A LOT of organization inside our CRM (Pipedrive) to stay current on everything. I decided back in November 2025 that this was a low ROI use of my time and I could probably automate this using the same tools I've been using to help automate some of my software engineering: Claude Code and skill files.

The one non-negotiable requirement I had, because all of our business involves delicate B2B contracts, is **Claude must not be able to send any emails without my explicit approval ever**. Essentially, I wanted pull request review for outbound emails - same type of workflow I'm used to running for my OSS projects.

TextForge email draft list \/ approval queue

I built up a primitive self-hosted MCP server + HTTP API that used a private Google Cloud API key scoped to our domain and got that working in about 5 days, wrote a CLI for Pipedrive that could access our deals and task list, and authored a Claude Code skill that combined the two of them to work deals. Then I spent about 2-3 months gradually refining it (threading, signatures, MIME handling, etc.) This all worked great and actually improved my close rate / ARR aging metrics pretty significantly by just staying on top of everything more frequently.

Then OpenClaw came out a few months later and just generally wreaked havoc in a lot of people's outbound email. People were asking for approval gates to prevent it from sending unauthorized emails / messages on their behalf, so I fired up Claude Code and started SaaSifying my self-hosted version: TextForge

I added webhook support (approve / reject without opening the app), attachment support, a secure pass-through architecture so we don't retain data, selective sync, all of the infrastructure needed for onboarding / billing. You can see an example of the whole workflow running below in Claude Code - it's pretty slick.

TextForge + Pipedrive + Claude Code doing email attachments and CRM sync

Google required us to pass a CASA2 audit in order to become verified so external Google users could use the service (reading emails is a restricted scope) so I used Claude to help me preempt a lot of what the reviewers would look for by executing an OpenProse workflow that scanned our app (ASP .NET Core) using the full set of OWASP vulnerabilities. I have a generalized version of that workflow here: https://gist.github.com/Aaronontheweb/83d1fc677c87e24c6ee4c779231dc096

That scan found a bunch of stuff we were able to fix before we got routed to Google's security audit partners. Our first scan came back mostly clean thanks to this, minus a few minor things we needed to clean up. The auditor required us to install an anti-virus system for scanning attachments, so I used Claude Code + Pulumi to help me fire up a ClamAV instance we use for this purpose. The audit took a few weeks (they wanted to look at everything, and rightly so) but it finally wrapped up last week.

I built all of this without writing hardly any of the code manually myself - but I spent a lot of time writing PRDs and tech specs, planning RALPH loops / OpenProse workflows, approving mock-ups and UI designs, testing the application by actually using it every day. It probably took me 500-600 hours total to get everything into the position that it's in now, so I certainly wouldn't call it "vibe coding."

TextForge costs $9.99 / $19.99 per month depending on which tier you select but it has a seven day free trial. I'd love to know if anyone finds it useful or what alternatives you use for this type of work.


id: 6cd481931948
title: sickn33/antigravity-awesome-skills
source_url: https://github.com/sickn33/antigravity-awesome-skills
source_platform: github
author: sickn33
published_at: 2026-03-15T16:53:23+00:00
collected_at: 2026-03-16T01:03:10.601000+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude Code", "Antigravity", "Cursor", "MCP", "Codex CLI", "Gemini CLI"]
novelty: similar
similar_to_ids: ["845dff761b29", "cba07222d406", "1a7b586fdac4", "a90e1fa2514d", "2009754ac555"]
summary:
这是一个包含1000+个代理技能的开源库，为Claude Code、Antigravity和Cursor等AI代理工具提供经过验证的高性能技能模块。该资源库整合了来自Anthropic和Vercel的官方技能，能够显著提升AI代理的自动化编码能力和工作流效率。

raw_content:
sickn33/antigravity-awesome-skills

The Ultimate Collection of 1000+ Agentic Skills for Claude Code/Antigravity/Cursor. Battle-tested, high-performance skills for AI agents including official skills from Anthropic and Vercel.

Topics: agentic-skills, ai-agents, ai-workflows, antigravity, autonomous-coding, claude-code, codex-cli, developer-tools, gemini-cli, mcp, prompt-engineering, skill-library
Language: Python | Stars: 24620


id: 1714cec3bc16
title: Leanstral: Open-source agent for trustworthy coding and formal proof engineering
summary: Leanstral是一个开源AI代理，专门用于可信编程和形式化证明工程。该工具结合Lean 4语言，能够自动生成并验证代码的数学正确性，适用于对代码可靠性有高要求的场景。
source_url: https://mistral.ai/news/leanstral
source_platform: hackernews
author: Poudlardo
published_at: 2026-03-16T20:59:40+00:00
collected_at: 2026-03-18T01:00:31.598340+00:00
scenario_type: 代码生成与审查
tools_used: ["Lean 4", "Leanstral"]
novelty: similar
similar_to_ids: ["c9f9395276c3", "6cd481931948", "5b6f4e63a641"]
raw_content:
Leanstral: Open-source agent for trustworthy coding and formal proof engineering

Lean 4 paper (2021): <a href="https:&#x2F;&#x2F;dl.acm.org&#x2F;doi&#x2F;10.1007&#x2F;978-3-030-79876-5_37" rel="nofollow">https:&#x2F;&#x2F;dl.acm.org&#x2F;doi&#x2F;10.1007&#x2F;978-3-030-79876-5_37</a>


id: 6d32ae370100
title: Show HN: Claude Code skills that build complete Godot games
source_url: https://github.com/htdt/godogen
source_platform: hackernews
author: htdt
published_at: 2026-03-16T16:07:29+00:00
collected_at: 2026-03-18T01:00:45.514179+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude Code", "Gemini Flash", "Godot 4", "GDScript"]
novelty: similar
similar_to_ids: ["6cd481931948", "c308aabe6a31", "1f770ae13aa5", "8d0142693489", "845dff761b29"]
summary:
Godogen是一个AI驱动的游戏开发管道,通过Claude Code技能将文本提示转化为完整可玩的Godot 4项目,包括架构设计、资产生成和GDScript代码编写。该系统通过构建GDScript专用参考库、处理编译时与运行时状态差异,以及引入独立的视觉QA代理来验证生成的游戏质量,解决了LLMs在游戏开发中的关键瓶颈。

raw_content:
Show HN: Claude Code skills that build complete Godot games

I’ve been working on this for about a year through four major rewrites. Godogen is a pipeline that takes a text prompt, designs the architecture, generates 2D&#x2F;3D assets, writes the GDScript, and tests it visually. The output is a complete, playable Godot 4 project.<p>Getting LLMs to reliably generate functional games required solving three specific engineering bottlenecks:<p>1. The Training Data Scarcity: LLMs barely know GDScript. It has ~850 classes and a Python-like syntax that will happily let a model hallucinate Python idioms that fail to compile. To fix this, I built a custom reference system: a hand-written language spec, full API docs converted from Godot&#x27;s XML source, and a quirks database for engine behaviors you can&#x27;t learn from docs alone. Because 850 classes blow up the context window, the agent lazy-loads only the specific APIs it needs at runtime.<p>2. The Build-Time vs. Runtime State: Scenes are generated by headless scripts that build the node graph in memory and serialize it to .tscn files. This avoids the fragility of hand-editing Godot&#x27;s serialization format. But it means certain engine features (like `@onready` or signal connections) aren&#x27;t available at build time—they only exist when the game actually runs. Teaching the model which APIs are available at which phase — and that every node needs its owner set correctly or it silently vanishes on save — took careful prompting but paid off.<p>3. The Evaluation Loop: A coding agent is inherently biased toward its own output. To stop it from cheating, a separate Gemini Flash agent acts as visual QA. It sees only the rendered screenshots from the running engine—no code—and compares them against a generated reference image. It catches the visual bugs text analysis misses: z-fighting, floating objects, physics explosions, and grid-like placements that should be organic.<p>Architecturally, it runs as two Claude Code skills: an orchestrator that plans the pipeline, and a task executor that implements each piece in a `context: fork` window so mistakes and state don&#x27;t accumulate.<p>Everything is open source: <a href="https:&#x2F;&#x2F;github.com&#x2F;htdt&#x2F;godogen" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;htdt&#x2F;godogen</a><p>Demo video (real games, not cherry-picked screenshots): <a href="https:&#x2F;&#x2F;youtu.be&#x2F;eUz19GROIpY" rel="nofollow">https:&#x2F;&#x2F;youtu.be&#x2F;eUz19GROIpY</a><p>Blog post with the full story (all the wrong turns) coming soon. Happy to answer questions.


id: 79f64a247e2a
title: Apideck CLI – An AI-agent interface with much lower context consumption than MCP
source_url: https://www.apideck.com/blog/mcp-server-eating-context-window-cli-alternative
source_platform: hackernews
author: gertjandewilde
published_at: 2026-03-16T15:25:36+00:00
collected_at: 2026-03-18T01:01:19.411123+00:00
scenario_type: 终端与CLI增强
tools_used: ["Apideck CLI", "MCP"]
novelty: similar
similar_to_ids: ["abb1b9505bb9", "4c49a6a48725", "faae7106be20"]
raw_content: Apideck CLI – An AI-agent interface with much lower context consumption than MCP
summary:
Apideck CLI是一个AI代理接口工具，相比MCP具有更低的上下文消耗，适用于开发者通过命令行与多个API和数据源进行交互。该解决方案优化了AI助手的资源使用效率，提高了工作流自动化的成本效益。


id: 4831c43f9ed8
title: which AI automation tools are people actually using day to day in 2026
source_url: https://www.reddit.com/r/nocode/comments/1rt9wg0/which_ai_automation_tools_are_people_actually/
source_platform: reddit
author: unknown
published_at: 2026-03-14T01:00:10.290000+00:00
collected_at: 2026-03-18T01:01:50.181629+00:00
scenario_type: 工作流自动化
tools_used: ["Zapier", "Make", "n8n", "Playwright", "Puppeteer", "Askui"]
novelty: similar
similar_to_ids: ["fb050128f45f", "9d622833f3fc", "2587854ae526", "a4713fb9eb43", "6885ba6c5ca2", "5471379ee4ff"]
summary:
讨论了2026年实际生产环境中使用的AI自动化工具，强调可靠性和维护性比新颖性更重要。用户基于QA需求选择了Zapier/Make处理API集成、n8n用于自托管控制、以及Askui用于跨平台UI自动化，形成了务实的工具栈组合。

raw_content:
which AI automation tools are people actually using day to day in 2026

which AI automation tools are people actually using day to day in 2026 : r/nocode Skip to main content which AI automation tools are people actually using day to day in 2026 : r/nocode

Go to nocode

r/nocode 3d ago

Significant_Heron852

# which AI automation tools are people actually using day to day in 2026

I have the impression that every company is claiming to be the best AI tool for automation right now and I am genuinely struggling to figure out which ones are actually running in production versus sitting in a pilot that never went anywhere. A lot of tools sound great until you try to run them on real devices or hand them off to a team that didn’t build them. From a QA perspective, reliability matters more than novelty (I’d rather use something boring that runs consistently than something flashy that needs constant tweaking)

After several months of evaluation we went with Zapier and Make for handling anything with clean API connections and they are still the default for straightforward workflow automation. No complaints there. n8n we brought in for the workflows where we needed more control and did not want data leaving our infrastructure. For browser and interface level automation we tested Playwright first but the maintenance overhead every time something changed in the frontend was becoming a real problem. We also tested Askui as it operates as an AI agent you control in plain language, it understands the interface through vision and DOM so it can execute tasks across web, desktop, and legacy software that has no API. For the flows where nothing else could reach it was the most reliable option we found. Still has limits on highly dynamic interfaces but the maintenance burden dropped significantly compared to what we had before.

for anyone who’s rolled out ai-based automation, which tools actually stuck and made it into your day-to-day? honest experiences only.

Read more

Share

---

• Promoted

Tasks here. Docs there. Chat somewhere else. Or… one workspace.

---

dreamywind69

3d ago

The stack you mentioned is pretty close to what I see in real production setups: Zapier/Make for simple API automation, n8n for self-hosted control, and Playwright for browser automation when APIs aren’t available

2

mprz

3d ago

LMAO

1

Aromatic-Musician-93

3d ago

From what I’m seeing in production environments right now, the tools that actually stick tend to be the boring but reliable ones.

For most teams I know, the stack usually looks something like this:

• Zapier / Make – still the default for API-based workflow automation. Easy to maintain and non-technical teams can use them.

• n8n – popular when teams want more control or need self-hosted workflows.

• Playwright / Puppeteer – still used for browser automation, but like you said the maintenance can get painful when the UI changes.

• AI agents layered on top of automation – this is where things are evolving fast, especially for tasks where APIs don’t exist.

One interesting direction I’ve seen lately is tools that combine automation + AI replies/communication. For example, apps like https://intentreply.com/ are being used to automatically generate and manage replies across platforms, which saves a lot of manual time for support or marketing teams.

In general though, the tools that survive in day-to-day use usually share a few traits:

simple to maintain

reliable with real workloads

easy for teams to adopt without engineers babysitting them

Curious to see what others are running in production too, especially for cross-app AI agents that don’t break every time the UI changes.

1

Borner-Crazy5785

3d ago

Yeah, it's like AI buzzword overload these days. We faced similar struggles in finding what's actually useful beyond the hype. For scraping stuff as part of test data collection, Scrappey kinda saved us a ton of hassle. Just works without fiddling with proxies or AI logic every time something changes. But day-to-day, it's more about consistency, so boring tools usually win.

1

Healthy_Library1357

3d ago

yeah the hype vs reality gap is pretty big right now. a lot of companies pilot flashy ai automation but never move it to production because reliability becomes the real bottleneck. most teams still rely on boring but stable tools like zapier, make, or n8n because they handle predictable workflows well and failure rates stay low. some surveys from dev teams last year showed around 60 to 70 percent of automation stacks still rely on traditional workflow tools, while ai agents are mostly used for edge cases like scraping, research, or tasks where there’s no clean api.

1

GildedGashPart

3d ago

For us it’s kind of similar to what you described: the “boring” stuff wins.

Zapier/Make for clean SaaS-to-SaaS wiring, they just work and non-devs can own them. n8n or custom Node services when we need more control / on‑prem.

For browser/UI we tried Playwright and Selenium, but test flakiness + constant locator updates were killing us. We’ve been experimenting with vision + DOM based tools too and yeah, the big win is lower maintenance when the frontend shifts slightly. They’re not magic on very dynamic apps, but still better than babysitting brittle selectors all week.

1

valentin-orlovs2c99

2d ago

Yeah, this is exactly where we landed too. The “sexy” tools look great in a demo and then quietly die once you give them to a real team and a flaky frontend.

Zapier/Make being something ops / marketing can actually own is such an underrated advantage. Every time an engineer has to touch a tiny workflow change, that automation is already half dead.

Curious on the vision + DOM side, did you end up standardizing on one tool yet or are you still in proof‑of‑concept land? We had the same pain with Playwright locator churn, and the first time we tried a vision-based agent that just kept working after a UI facelift it was like “oh, so this is what sanity feels like.”

Totally agree on “not magic on very dynamic apps” too. Seems like the sweet spot is all the semi-stable internal tools and legacy stuff where no one will ever give us an API.

1

Continue this thread

TechnicalSoup8578

3d ago

Your stack sounds pretty representative of what’s actually sticking in production right now. Have you noticed a pattern in which types of workflows stay stable versus the ones that constantly break and need maintenance? You should share it in VibeCodersNest too

1

TomasPiaggio

2d ago

I’ve been building a ton of small little automations yo my workflow. I have a twitter bot that shows me trends that might interest me to tweet about and another that helps me write blogs based on what’s working best. It’s mostly based on claude code and openclaw

1

Few_Look_5477

2d ago

Noclick

1

• Promoted

Otter.ai: Your AI meeting assistant. Records audio, captures notes, & generates summaries.

talakoubali

2d ago

Here's what's actually running in my stack daily:

n8n for workflows -- self-hosted, handles all my triggers, routing, and integrations. Nothing comes close for the price (free if self-hosted).

OpenRouter for all LLM calls -- model-agnostic, so I can swap between Claude, GPT, Gemini without rewriting anything. Also means I'm not locked in if pricing changes.

OpenClaw for AI agent execution -- good for anything that needs multi-step reasoning or tool use. Works best when paired with n8n as the execution layer.

Chatwoot for customer messaging. Airtable as a lightweight CRM.

The main thing I've learned: don't pick tools that do everything. Pick tools that do one thing well and connect them. The stack above handles a full AI receptionist for a client, daily content workflows, and my own business ops.

I'm actually building a platform on top of this stack (SuperAgent -- getsuperagent.cloud) to make this setup accessible without having to wire everything together manually. Still early but worth checking out if you're deep into this.

1

Long_Bullfrog4995

5m ago

We use Punku AI for all our customer facing bots that needs to stay up. No IDE, no YAML, just "answer booking questions, pull slots from Bookingkit, confirm via Gmail." That’s it, and the agent lives 24/7. Tried Askui first for a legacy front-end flow and it still broke whenever the devs moved a button. Switched those to punku templates and haven’t touched them since

1

Otherwise_Wave9374

3d ago

Totally feel this. The gap between "cool agent demo" and "runs every day without babysitting" is huge. In my experience the stuff that sticks is usually boring plumbing plus clear guardrails: deterministic steps where possible, retries/timeouts, and very explicit success criteria for the agent (otherwise it just meanders).

If you are comparing agent-style automation, one thing thats helped our team is treating it like a product, eval sets, logs, and a simple rubric for "did the agent actually finish". Weve been collecting patterns and checklists here too, in case its useful: https://www.agentixlabs.com/blog/

0

make-pro

3d ago

I work at Make and we have an increasingly number of customers claiming to use Make as their AI Automation tool of choice for their Production environment. They usually highlight the ease to maintain the workflows, even by teams without a technical background.

We also try to constantly incorporate additional features aiming to improve AI workflow reliability , scalability and debugging. Some recent examples are the Make Grid, which provides a wide-angle view on workflow dependencies and interconnections, or the AI Agent Reasoning Panels, which make debugging AI Agent-based workflows way easier and intuitive.

0

VelvetViciousArdor

17h ago

Nice, that actually tracks with what we saw. Make felt a lot less intimidating for non-devs than n8n, and the visual layout is a big reason it stuck.

Curious how people are using the AI Agent Reasoning Panels in practice though. Are folks mostly using them to debug the occasional weird run, or are teams sitting there and tuning prompts/flows based on what they see?

1

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.

Expand Navigation Collapse Navigation


id: 03eed7f43e7d
title: Launch HN: Voygr (YC W26) – A better maps API for agents and AI apps
source_url: https://news.ycombinator.com/item?id=47401042
source_platform: hackernews
author: ymarkov
published_at: 2026-03-16T16:21:07+00:00
collected_at: 2026-03-18T01:01:59.917956+00:00
scenario_type: 本地数据集成
tools_used: ["Voygr Maps API", "Business Validation API", "Web scraping/data aggregation"]
novelty: similar
similar_to_ids: ["e4f7d4fe231b", "39d6b08b7043", "5ff4bf30ae94"]
summary:
Voygr是一个为AI代理和应用开发者提供的地点智能API，通过整合多个数据源和实时网络内容（新闻、文章、事件等）来提供动态、可查询的地点信息，解决传统地图API数据过时的问题。该解决方案特别针对LLM和AI代理在真实世界中搜索、预订和购物时需要准确的本地上下文的场景，可验证商业是否真实运营。

raw_content:
Launch HN: Voygr (YC W26) – A better maps API for agents and AI apps

Hi HN, we’re Yarik and Vlad from VOYGR (<a href="https:&#x2F;&#x2F;voygr.tech&#x2F;">https:&#x2F;&#x2F;voygr.tech&#x2F;</a>), working on better real-world place intelligence for app developers and agents. Here’s a demo: <a href="https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=cNIpcWIE0n4" rel="nofollow">https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=cNIpcWIE0n4</a>.<p>Google Maps can tell you a restaurant is &quot;4.2 stars, open till 10.&quot; Their API can&#x27;t tell you the chef left last month, wait times doubled, and locals moved on. Maps APIs today just give you a fixed snapshot. We&#x27;re building an infinite, queryable place profile that combines accurate place data with fresh web context like news, articles, and events.<p>Vlad worked on the Google Maps APIs as well as in ridesharing and travel. Yarik led ML&#x2F;Search infrastructure at Apple, Google, and Meta powering products used by hundreds of millions of users daily. We realized nobody was treating place data freshness as infrastructure, so we&#x27;re building it.<p>We started with one of the hardest parts - knowing whether a place is even real. Our Business Validation API (<a href="https:&#x2F;&#x2F;github.com&#x2F;voygr-tech&#x2F;dev-tools" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;voygr-tech&#x2F;dev-tools</a>) tells you whether a business is actually operating, closed, rebranded, or invalid. We aggregate multiple data sources, detect conflicting signals, and return a structured verdict. Think of it as continuous integration, but for the physical world.<p>The problem: ~40% of Google searches and up to 20% of LLM prompts involve local context. 25-30% of places churn every year. The world doesn&#x27;t emit structured &quot;I closed&quot; events - you have to actively detect it. As agents start searching, booking, and shopping in the real world, this problem gets 10x bigger - and nobody&#x27;s building the infrastructure for it. We recently benchmarked how well LLMs handle local place queries (<a href="https:&#x2F;&#x2F;news.ycombinator.com&#x2F;item?id=47366423">https:&#x2F;&#x2F;news.ycombinator.com&#x2F;item?id=47366423</a>) - the results were bad: even the best gets 1 in 12 local queries wrong<p>We&#x27;re processing tens of thousands of places per day for enterprise customers, including leading mapping and tech companies. Today we&#x27;re opening API access to the developer community. Please find details here: <a href="https:&#x2F;&#x2F;github.com&#x2F;voygr-tech&#x2F;dev-tools" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;voygr-tech&#x2F;dev-tools</a><p>We&#x27;d love honest feedback - whether it&#x27;s about the problem, our approach, or where you think we&#x27;re wrong. If you&#x27;re dealing with stale place data in your own products, we&#x27;d especially love to hear what breaks. We&#x27;re here all day, AMA.


id: d81ecea08336
title: Show HN: Horizon – GPU-accelerated infinite-canvas terminal in Rust
source_url: https://github.com/peters/horizon
source_platform: hackernews
author: petersunde
published_at: 2026-03-17T18:14:24+00:00
collected_at: 2026-03-18T01:02:36.248741+00:00
scenario_type: 终端与CLI增强
tools_used: ["Horizon", "Claude/Codex", "Rust", "GPU"]
novelty: similar
similar_to_ids: ["52d44a688882", "1d33fcd888f9", "e1e06f6feb29"]
summary:
Horizon是一个GPU加速的无限画布终端应用，通过将多个Shell会话组织到可视化工作区中来解决传统终端标签页的上下文切换问题。该工具支持保存和恢复完整的工作环境布局、滚动历史和命令历史，显著提升了开发者的工作流效率。

raw_content:
Show HN: Horizon – GPU-accelerated infinite-canvas terminal in Rust

Tabs, splits, and tmux work fine until you have several projects open with logs, tests, and long-running shells. I kept rebuilding context instead of resuming work. Horizon puts shells on an infinite canvas. You can arrange them into workspaces and reopen later with layout, scrollback, and history intact.<p>Built in 3 days with Claude&#x2F;Codex, dogfooding the workflow as I went. Feedback and contributions welcome.


id: de2ce3f50104
source_platform: reddit
author: t2_1m70tvuvm4
published_at: 2026-03-18T01:00:10.552489+00:00
collected_at: 2026-03-18T01:02:49.983740+00:00
scenario_type: 工作流自动化
novelty: similar
similar_to_ids: ["a4713fb9eb43", "628765deddd5", "8d1fb8062ab4", "da6cd49c549c", "2587854ae526", "066cf297b71a"]
title:
https://www.reddit.com/r/OpenClawBuilders/comments/1rqr7r1/the_ultimate_openclaw_guide_how_i_broke_free_from.json

summary:
OpenClaw是一个开源的模块化AI自动化平台，通过Gateway、Channels、Skills和Workflow Engine等五大组件实现跨多个通讯渠道的工作流自动化。该平台支持自主部署、零许可费用，提供60倍月度ROI和显著的业务流程优化（如电子邮件分类效率提升78%、客户入驻速度提升12倍），适合企业级应用。

source_url:
https://www.reddit.com/r/OpenClawBuilders/comments/1rqr7r1/the_ultimate_openclaw_guide_how_i_broke_free_from.json

tools_used:
["OpenClaw", "Node.js", "TypeScript", "Docker", "Kubernetes", "SwiftUI", "Lobster", "ClawHub", "WhatsApp", "Telegram", "Discord", "Slack"]

raw_content:
https://www.reddit.com/r/OpenClawBuilders/comments/1rqr7r1/the_ultimate_openclaw_guide_how_i_broke_free_from.json

# WHAT IS OPENCLAW? ARCHITECTURE DEEP DIVE

OpenClaw is not just another chatbot. It’s a modular, five-component AI automation platform:

* **Gateway:** The beating heart. Routes messages, manages sessions, executes plugins, and orchestrates workflows.
* **Channels:** Bridges to WhatsApp, Telegram, Discord, iMessage, Slack, Signal, and more. Your AI agent lives where your team already works.
* **Skills/Plugins:** Modular extensions—think web search, document parsing, browser automation, API calls. 13,000+ skills on ClawHub, or build your own in TypeScript.
* **Workflow Engine:** Compose multi-step automations, chain skills, and build pipelines with Lobster—the native workflow shell.
* **Browser Dashboard:** Web UI for managing sessions, workflows, and configuration. SwiftUI apps for macOS/iOS; browser-based for everything else.

**Tech Stack:**

* TypeScript/JavaScript (Node.js v22+), SwiftUI (macOS/iOS), Docker, Python (for select skills).

**Why does this matter?** 
 Because you get a system that’s both developer-friendly and business-ready. You can run it on your laptop, a $5 VPS, or scale it to Kubernetes in the cloud. You own the stack, the data, and the roadmap .





# SECTION 3 — THE BUSINESS CASE (FOR DECISION-MAKERS)

Let’s talk numbers—because that’s what matters to decision-makers.

# ROI: Real, Quantifiable, Immediate

* **60x ROI in Month One:** A 5-person team automating 10 hours/week at $50/hr, with 60% automation, saves $6,000/month. OpenClaw’s infra + API costs? \~$100/month. That’s a 60x return, instantly.
* **Case Studies:**
 * 78% reduction in email triage time.
 * 12x faster client onboarding.
 * KPI reporting: 4–6 hours → 5 minutes.
* **Zero Licensing Fees:** MIT license. No per-seat, no per-feature, no “enterprise” upcharge. You pay for infra ($5–$50/month VPS) and AI API usage ($25–$100/month typical business use) .

# Competitor Comparison

|**Feature/Metric**|**OpenClaw**|**ZeroClaw**|**Adopt AI**|**Zapier/Power Automate**|
|:-|:-|:-|:-|:-|
|Open Source|Yes (MIT)|No|No|No|
|Self-Hosting|Yes (Docker/K8s)|Yes (edge)|No|No|
|Licensing Cost|$0|$20k/mo|$10k+/yr|Subscription|
|Extensibility|13,000+ skills|22+ connectors|Yes|Limited|
|Native Connectors|50+|22+|Yes|Yes|
|Performance|200–500ms, 1k/s|10–20ms, 500/s|N/A|N/A|
|Compliance|SOC2, ISO, GDPR|ISO|SOC2, ISO, GDPR|Yes|
|Community Size|191k+ stars|5k+ stars|N/A|Large|

**Notable adopters:** 
 Silicon Valley and China tech companies, Hitachi Vantara senior leadership, Shenzhen City AI Bureau (government proposal) .





# SECTION 4 — SYSTEM REQUIREMENTS &amp; PRE-FLIGHT CHECKLIST

Before you start, check these boxes:

* **CPU/RAM:** 2 vCPU / 4GB RAM minimum (4 vCPU / 8GB+ recommended)
* **Disk:** 5GB+ free
* **OS:** Linux (Ubuntu 20.04+), macOS 14+, Windows 10/11 (WSL2), Docker, or cloud VM
* **Node.js:** v22+ (not v18/v20)
* **pnpm:** Preferred package manager
* **git:** For repo cloning
* **Docker:** Optional, for containerized install
* **API Keys:** OpenAI or Anthropic (for LLMs)





# SECTION 5 — INSTALLATION: THREE PATHS

# Path A: Quick Install Script (All Platforms)

curl -fsSL https://openclaw.ai/install.sh | bash

**Windows PowerShell:**

curl -fsSL https://openclaw.ai/install.cmd \-o install.cmd &amp;&amp; install.cmd &amp;&amp; del install.cmd

# Path B: Manual Developer Install

**Install Node.js v22+ (with nvm):** 
 curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash 
source \~/.bashrc 
nvm install 22 
nvm use 22



**Install pnpm:** 
 npm install -g pnpm



**Clone and build:** 
 git clone https://github.com/openclaw/openclaw.git 
cd openclaw 
pnpm install 
pnpm run build 
pnpm ui:build 
pnpm openclaw onboard --install-daemon



# Path C: Docker Install (Production-Hardened)

\# docker-compose.yml 
version: '3.8' 
services: 
  openclaw-gateway: 
image: openclaw/openclaw:latest 
container\_name: openclaw-gateway 
restart: unless-stopped 
user: "1000:1000" 
read\_only: true 
cap\_drop: 
\- ALL 
security\_opt: 
\- no-new-privileges:true 
tmpfs: 
\- /tmp:rw,noexec,nosuid,size=100m 
\- /var/tmp:rw,noexec,nosuid,size=50m 
volumes: 
\- ./config:/home/node/.openclaw/config:rw 
\- ./workspace:/home/node/.openclaw/workspace:rw 
\- ./state:/home/node/.openclaw/state:rw 
networks: 
\- openclaw-internal 
ports: 
\- "127.0.0.1:18789:18789" 
mem\_limit: 2g 
cpus: 2 
pids\_limit: 100 
environment: 
\- NODE\_ENV=production 
\- OPENCLAW\_AUTH\_TOKEN=${OPENCLAW\_AUTH\_TOKEN} 
\- ANTHROPIC\_API\_KEY=${ANTHROPIC\_API\_KEY} 
networks: 
  openclaw-internal: 
driver: bridge 
internal: true

docker compose up -d





# SECTION 6 — CONFIGURATION DEEP DIVE

* **Config file:** \~/.openclaw/openclaw.json (JSON5, supports comments)

**CLI commands:** 
 openclaw config get 
openclaw config set &lt;key&gt; &lt;value&gt;

* **Environment variables:** Place in \~/.openclaw/.env or project root.
 * OPENAI\_API\_KEY, ANTHROPIC\_API\_KEY, OPENCLAW\_LOG\_LEVEL, OPENCLAW\_API\_PORT, OPENCLAW\_AUTH\_TOKEN
* **Override config path:** OPENCLAW\_CONFIG\_PATH=/custom/path/openclaw.json
* **Dual config modes:**
 * **merge:** Preserves runtime changes
 * **overwrite:** Strict GitOps, config is replaced on deploy





# SECTION 7 — DEPLOYMENT OPTIONS: LOCAL TO KUBERNETES

* **Local:** For dev, run directly on your machine.
* **Docker Compose:** Recommended for production. Use the hardened compose file above.
* **VPS/Cloud:** DigitalOcean 1-Click, Contabo, Hostinger—deploy with Docker Compose.

**Kubernetes (Helm):** 
 helm repo add openclaw https://serhanekicii.github.io/openclaw-helm 
helm install openclaw openclaw/openclaw -f values.yaml

 * Supports StatefulSet, Chromium sidecar, init containers.

**ArgoCD Manifest Example:** 
 apiVersion: argoproj.io/v1alpha1 
kind: Application 
metadata: 
  name: openclaw 
spec: 
  ignoreDifferences: 
\- group: "" 
kind: ConfigMap 
name: openclaw 
jsonPointers: 
\- /data



**CI/CD Integration:** 
 GitHub Actions webhook step: 
 \- name: Notify OpenClaw 
  run: | 
curl -X POST ${{ secrets.OPENCLAW\_WEBHOOK }} \\ 
\-H 'Content-Type: application/json' \\ 
\-d '{"event": "deployment", "status": "success", "commit": "${{ github.sha }}"}'

*  Or use the ai-github-action skill for workflow generation.
* **Cloudflare Moltworker:** Managed, serverless OpenClaw—no infra to manage.

**Performance tuning:**

* Increase mem\_limit, cpus in Docker/K8s.
* Use caching, log rotation, and monitor with openclaw status --deep.





# SECTION 8 — CORE USAGE &amp; ESSENTIAL COMMANDS

|**Command**|**Description**|
|:-|:-|
|openclaw onboard|Interactive setup wizard|
|openclaw gateway start|Start the gateway process|
|openclaw gateway status|Check gateway status|
|openclaw dashboard|Launch browser dashboard|
|openclaw doctor|Diagnostics and troubleshooting|
|openclaw plugin install|Install plugin from registry or GitHub|
|openclaw plugin list|List installed plugins|
|openclaw plugin search|Search for plugins|
|openclaw plugin init|Scaffold a new plugin|
|openclaw plugin validate|Validate plugin before publishing|
|openclaw plugin publish|Publish plugin to registry|
|openclaw skill install|Install skill from ClawHub or local directory|
|openclaw run &lt;workflow&gt;|Execute a named workflow or pipeline|

**First workflow, end-to-end:**

openclaw onboard 
openclaw skill install clawhub:google-drive 
openclaw skill install clawhub:gmail 
openclaw run onboard-client --name "John Doe" --email "john@example.com"

**Lobster workflow shell:** 
 Chain skills into pipelines, with type safety and resumable execution.





# SECTION 9 — REAL-WORLD USE CASES &amp; WORKFLOWS

# Business Automation: Automated Client Onboarding

1. User sends: onboard new client John Doe john@example.com
2. Workflow:
 * Create Google Drive folder
 * Send templated welcome email
 * Add onboarding call to calendar
 * Log client info to CRM spreadsheet
3. Result: Confirmation in chat, all resources provisioned.

# DevOps &amp; Coding

* PR reviews, dependency scans, GitHub issue management, cron jobs.

# Content Production

* Video editing, image generation, audio transcription, social scheduling.

# Data Extraction

* Parse receipts, extract data, log to spreadsheets.

# Knowledge Management

* Build searchable knowledge bases from URLs, tweets, articles.

# Sales &amp; Outreach

* CRM updates, lead research, personalized outreach, 24/7 agent availability.

# Customer Support

* FAQ routing, ticket escalation, multi-channel support.

# Trading &amp; Analytics

* Backtesting, daily performance reports.





# SECTION 10 — ADVANCED PATTERNS &amp; THE PLUGIN ECOSYSTEM

* **Lobster Pipelines:** Compose multi-step, typed workflows.
* **Parallel Execution &amp; Retries:** Plugins support parallelism and auto-retries.
* **Docker Sandboxing:** Skills run in isolated containers for security.
* **Custom Plugins:** Scaffold with openclaw plugin init, validate, and publish.
* **MemOS Cloud Plugin:** Persistent, context-aware memory for agents.
* **GitHub Integration Skill:** Automate PRs, issues, and repo management.
* **ClawHub:** 13,000+ community skills, curated and production-tested.





# SECTION 11 — COMMON ERRORS &amp; TROUBLESHOOTING TABLE

|**Issue/Error**|**Solution**|
|:-|:-|
|Node.js version mismatch (not v22+)|nvm install 22 &amp;&amp; nvm use 22|
|npm EACCES errors|Use nvm for user-local installs|
|Dependency build failures|Install build tools (build-essential/Xcode CLI)|
|Gateway not in PATH|Restart terminal, ensure node\_modules/.bin is in PATH|
|Port conflicts (default 18789/3000 in use)|\`lsof -ti:PORT|
|openclaw.json parse errors|Validate with JSON linter, rerun onboarding|
|Missing API keys|Set in .env or environment before starting|
|Windows Node.js not in PATH|Add Node.js to PATH, restart terminal|
|macOS Homebrew Node.js not in PATH|Add Homebrew path to .zshrc or .bash\_profile|

**Pro Tip:** 
 Always run openclaw doctor first—it catches 90% of config and environment issues.





# SECTION 12 — SECURITY HARDENING CHECKLIST

* Run as non-root user (user: "1000:1000" in Docker)
* Read-only root filesystem (read\_only: true)
* Drop all Linux capabilities (cap\_drop: ALL)
* Bind to localhost or internal network only
* Store API keys in secrets manager or environment variables
* Enable RBAC, OAuth2, AES-256 (OpenClaw supports all)
* Enable audit logging
* Audit installed skills—use only trusted sources
* Update OpenClaw and dependencies regularly
* Restrict channel allowlists
* Use Docker network isolation





# SECTION 13 — SUPPORT, COMMUNITY, AND NEXT STEPS

* **Community:**
 * GitHub: github.com/openclaw/openclaw
 * Discord: Active support and discussion
 * Docs: docs.openclaw.ai
 * ClawHub: 13,000+ skills registry
* **Commercial Options:**
 * OpenClaw Cloud from $19/month
 * Magicteams ai managed hosting
* **Contribute:**
 * Fork the repo, submit PRs, or publish your own skill via openclaw plugin publish
* **Next Steps:**
 * Deploy your first workflow
 * Join the community
 * Share your use case—become part of the open automation revolution





**Final Word:** 
 OpenClaw is the AI automation framework I wish I’d had years ago. It’s open, extensible, and battle-tested. Whether you’re a developer who wants to build the next killer workflow, or a business owner who’s done with SaaS lock-in, OpenClaw is your ticket to true AI freedom. Don’t just automate—own your automation.


id: 716ca1c81001
title: Launch HN: Chamber (YC W26) – An AI Teammate for GPU Infrastructure
source_url: https://www.usechamber.io/
source_platform: hackernews
author: jshen96
published_at: 2026-03-16T17:09:34+00:00
collected_at: 2026-03-18T01:03:00.504376+00:00
scenario_type: 商业流程自动化
tools_used: ["Chamber", "Kubernetes", "Prometheus", "Grafana", "GPU infrastructure management"]
novelty: similar
similar_to_ids: ["f04f8a6aa88f", "9e6735e3c6a2", "383475726b14"]
summary:
Chamber是一个AI代理平台，通过自动化GPU基础设施管理来优化DevOps工作流，包括集群配置、故障诊断和工作负载管理。该产品针对平台工程师花费大量时间维护GPU集群的痛点，提供了具有分级自主权和完整操作日志的安全自动化解决方案。这是一个明确的企业级基础设施自动化应用，具有很高的实践价值。

raw_content:
Launch HN: Chamber (YC W26) – An AI Teammate for GPU Infrastructure

Hey HN, we&#x27;re Jie Shen, Charles, Andreas, and Shaocheng. We built Chamber (<a href="https:&#x2F;&#x2F;usechamber.io">https:&#x2F;&#x2F;usechamber.io</a>), an AI agent that manages GPU infrastructure for you. You talk to it wherever your team already works and it handles things like provisioning clusters, diagnosing failed jobs, managing workloads. Demo: <a href="https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=xdqh2C_hif4" rel="nofollow">https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=xdqh2C_hif4</a><p>We all worked on GPU infrastructure at Amazon. Between us we&#x27;ve spent years on this problem — monitoring GPU fleets, debugging failures at scale, building the tooling around it. After leaving we talked to a bunch of AI teams and kept hearing the same stuff. Platform engineers spend half their time just keeping things running. Building dashboards, writing scheduling configs, answering &quot;when will my job start?&quot; all day. Researchers lose hours when a training run fails because figuring out why means digging through Kubernetes events, node logs, and GPU metrics in totally separate tools. Pretty much everyone had stitched together Prometheus, Grafana, Kubernetes scheduling policies, and a bunch of homegrown scripts, and they were spending as much time maintaining all of it as actually using it.<p>The thing we kept noticing is that most of this work follows patterns. Triage the failure, correlate a few signals, figure out what to do about it. If you had a platform with structured access to the full state of a GPU environment, you could have an agent do that work for you.<p>So that&#x27;s what we built. Chamber is a control plane that keeps a live model of your GPU fleet: nodes, workloads, team structure, cluster health. Every operation it supports is exposed as a tool the agent can call. Inspecting node health, reading cluster topology, managing workload lifecycle, adjusting resource configs, provisioning infrastructure. These are structured operations with validation and rollback, not just raw shell commands. When we add new capabilities to the platform, they automatically become things the agent can do too.<p>We spent a lot of time on safety because we&#x27;ve seen what happens when infrastructure automation goes wrong. A wrong call can kill a multi-day training run or cascade across a cluster. So the agent has graduated autonomy. Routine stuff it handles on its own: diagnosing a failed job, resubmitting with corrected resources, cordoning a bad node. But anything that touches other teams&#x27; workloads or production jobs needs human approval first. Every action gets logged with what the agent saw, why it acted, and what it changed.<p>The platform underneath is really what makes the diagnosis work. When the agent investigates a failure, it queries GPU state, workload history, node health timelines, and cluster topology. That&#x27;s the difference between &quot;your job OOMed&quot; and &quot;your job OOMed because the batch size exceeded available VRAM on this node, here&#x27;s a corrected config.&quot; Different root causes get different fixes.<p>One thing that surprised us, even coming from Amazon where we&#x27;d seen large GPU fleets: most teams we talk to can&#x27;t even tell you how many GPUs are in use right now. The monitoring just doesn&#x27;t exist. They&#x27;re flying blind on their most expensive hardware.<p>We’ve launched with a few early customers and are onboarding new teams. We’re still refining pricing and are currently evaluating models like per-GPU-under-management and tiered plans. We plan to publish transparent pricing once we’ve validated what works best for customers. In the meantime, we know “contact us” isn’t ideal.<p>Would love to hear from anyone running GPU clusters. What&#x27;s the most tedious part of your setup? What would you actually trust an agent to do? What&#x27;s off limits? Looking forward to feedback!


id: 67b1df9700cf
title: Launch HN: Kita (YC W26) – Automate credit review in emerging markets
source_url: https://news.ycombinator.com/item?id=47417335
source_platform: hackernews
author: rheamalhotra1
published_at: 2026-03-17T19:46:29+00:00
collected_at: 2026-03-18T01:03:10.492504+00:00
scenario_type: 商业流程自动化
tools_used: ["VLM (Vision Language Models)", "OCR", "Document AI", "Machine Learning Models"]
novelty: similar
similar_to_ids: ["2f043903e426", "d643c0c3dbe7", "954dc3a3a586"]
summary:
Kita使用视觉语言模型(VLM)自动化新兴市场的信用审查流程,通过智能文档解析、欺诈检测和结构化数据提取,替代传统手动审查。该解决方案针对新兴市场金融文件格式多样、质量参差不齐的特点进行优化,显著降低了信贷机构的审批成本、时间和错误率。

raw_content:
Launch HN: Kita (YC W26) – Automate credit review in emerging markets

Hey HN! We’re Carmel and Rhea, the founders of Kita (<a href="https:&#x2F;&#x2F;www.usekita.com&#x2F;">https:&#x2F;&#x2F;www.usekita.com&#x2F;</a>). We automate credit review for lenders in emerging markets using VLMs.<p>In many emerging markets, like the Philippines and Mexico, credit infrastructure is weak. Open finance is still nascent, and credit bureaus are unreliable. So to apply for a loan, lenders rely on borrowers submitting documentation to understand their ability to repay. A borrower can submit financial documents, such as bank statements and payslips, in any format, from pdfs, images of physical documents and screenshots. On top of that, financial documents in these markets are highly unstandardized, with no consistent templates lenders can rely on.<p>Existing OCR and document AI tools break on these highly variant, messy real-world documents. Generic tools are not built for lending workflows like verification, fraud detection, and risk extraction. As a result, credit teams fall back on manual review, making underwriting slower, more expensive, and more error-prone.<p>We met before college and stayed best friends. After graduating, Rhea visited Carmel in the Philippines, where we heard firsthand from fintech operators that document-based underwriting was their biggest pain point. We started building together and tested every OCR and document AI tool we could find. They all failed on the messy real-world documents lenders actually receive, and even when extraction worked, they still could not produce the structured financial data or fraud checks lenders needed.<p>The problem was even bigger than we thought. Across Indonesia, Mexico, the Philippines, South Africa, and even in the US, most of lending can be boiled down to credit analysts looking at documents. In 2025, 13.3T was lended globally, and 90% of those transactions involved document review. This includes in developed markets.<p>Kita uses VLM-based agents to parse documents, detect fraud, and extract underwriting signals from messy financial files. Today, we support 50+ document types across PDFs, scans, photos, and screenshots. Our pipeline enhances low-quality inputs, extracts structured financial data, and verifies it through cross-document checks, validation against our historical database, and market-specific fraud detection.<p>Our architecture’s base VLM is model agnostic, and simultaneously, we train language models finetuned to hyperlocalized credit signals in each market, using localized lender data – every new model improves our base layer, and every new market makes our overall stack stronger. We link document-level signals to repayment outcomes, allowing our models to continuously improve fraud detection and risk assessment over time.<p>Kita Capture is our first document intelligence product for lenders. We’re also launching Kita Credit Agent, which automates borrower follow-up during origination over WhatsApp and email to collect missing documents and complete loan applications.<p>Kita Capture is free to try (with email signup): <a href="https:&#x2F;&#x2F;portal.usekita.com&#x2F;">https:&#x2F;&#x2F;portal.usekita.com&#x2F;</a>. Here’s a quick demo: <a href="https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=4-t_UhPNAvQ" rel="nofollow">https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=4-t_UhPNAvQ</a>.<p>We’d love to get feedback from the community, especially if you’ve worked on document AI, fraud detection, or fintech infrastructure. Thanks for reading!


id: 3ebfd70a08ab
title: AskVibecoders
source_url: https://www.reddit.com/r/AskVibecoders/hot/
source_platform: reddit
author: unknown
published_at: 2026-03-18T01:00:11.852399+00:00
collected_at: 2026-03-18T01:03:34.165865+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude API", "Claude Subagents", "Agent Teams", "SDK"]
novelty: similar
similar_to_ids: ["8d0142693489", "5b6f4e63a641", "19e007cf2bb9", "c22de644b867"]
summary:
本文介绍了Claude Subagents和Agent Teams两种AI代理架构范式的区别与应用。Subagents通过隔离上下文和压缩结果来处理特定任务，而Agent Teams则提供持久化协作能力，适用于复杂的多角色工作流。该内容为开发者提供了清晰的架构选择指导，具有较高的实践价值。

raw_content:
AskVibecoders

AskVibecoders Skip to main content AskVibecoders

# r/AskVibecoders Become the best vibecoder in the world!

Create Post

Feed About

Hot

Open sort options

Change post view

### Community highlights

---

Claude Subagents vs. Agent Teams. Explained Simply

u/Worldly_Ad_2410

19 hr. ago Claude Subagents vs. Agent Teams. Explained Simply

```
from claude_agent_sdk import query, ClaudeAgentOptions, AgentDefinition

async def main():
    async for message in query(
        prompt="Review the authentication module for security vulnerabilities",
        options=ClaudeAgentOptions(
            allowed_tools=["Read", "Grep", "Glob", "Agent"],
            agents={
                "security-reviewer": AgentDefinition(
                    description="Security specialist. Use for vulnerability checks and security audits.",
                    prompt="You are a security specialist with expertise in identifying vulnerabilities.",
                    tools=["Read", "Grep", "Glob"],
                    model="sonnet",
                ),
                "performance-optimizer": AgentDefinition(
                    description="Performance specialist. Use for latency issues and optimization reviews.",
                    prompt="You are a performance engineer with expertise in identifying bottlenecks.",
                    tools=["Read", "Grep", "Glob"],
                    model="sonnet",
                ),
            },
        ),
    ):
        print(message)
```

```
Claude (Team Lead):
└── spawnTeam("auth-feature")
    Phase 1 - Planning:
    └── spawn("architect", prompt="Design OAuth flow", plan_mode_required=true)
    Phase 2 - Implementation (parallel):
    └── spawn("backend-dev", prompt="Implement OAuth controller")
    └── spawn("frontend-dev", prompt="Build login UI components")
    └── spawn("test-writer", prompt="Write integration tests", blockedBy=["backend-dev"])
```

- Compact

Claude gives you two paradigms: subagents and agent teams. They look similar. They solve completely different problems. Subagents: isolate and compress A subagent is a Claude instance running in its own context window, with its own system prompt, its own tool access, and one job to do. When it finishes, only the result comes back to the parent. Not the reasoning. Not the intermediate steps. Just the output. That's the actual value: compression. You're distilling a large amount of exploration into a clean signal without polluting the parent agent's context. One constraint worth understanding: subagents can't spawn other subagents and can't talk to each other. Everything flows back to the parent. The parent coordinates everything. This is a feature. You always know where decisions get made. The description field is the routing signal. The prompt mentions "security vulnerabilities" so the parent picks security-reviewer. Ask about latency and it picks performance-optimizer. Keep descriptions specific or routing breaks. Agent teams: persistent and collaborative Subagents are fire-and-forget. Agent teams are different: they persist, accumulate context, and communicate directly with each other. Three parts: a team lead that coordinates and synthesizes, teammates that are independent agent instances working in parallel, and a shared task list tracking dependencies. The blockedBy field on the test writer means it won't start until the backend agent finishes. The lead doesn't have to manage that sequencing manually. The bigger difference from subagents: teammates talk to each other directly. A frontend agent can tell a backend agent the Application Programming Interface response structure needs to change and the backend agent adjusts without waiting for the lead to mediate. How to choose Use subagents when tasks are genuinely independent: separate research streams, codebase exploration, lookups where the parent only needs the summary. Use agent teams when tasks require ongoing negotiation: agents that need to reconcile outputs before proceeding, or where a discovery in one thread changes what another thread should do. Split by context, not by role The common failure: splitting work by role. Planner, implementer, tester. Feels organized. Creates a telephone game where information degrades at every handoff. The implementer doesn't have what the planner knew. The tester doesn't have what the implementer decided. Split by context instead. Ask what information a subtask actually needs. If two subtasks need deeply overlapping context, they belong to the same agent. If they can operate with truly isolated information and clean interfaces, that's where you split. Practical example: the agent implementing a feature should also write the tests. It already has the context. Splitting those into separate agents creates a handoff problem that costs more than the parallelism saves. Five patterns that cover most cases Prompt chaining: Sequential steps where each call processes the previous output. Use when order matters and steps depend on each other. Routing: A classifier sends the task to the right handler. Easy questions go to faster, cheaper models. Hard ones go to more capable models. This is how you control costs. Parallelization: Independent subtasks run simultaneously, either the same task multiple times for diverse outputs, or different subtasks at the same time. Orchestrator-worker: A central agent breaks down the task, delegates to workers, synthesizes results. Most production systems use this. Evaluator-optimizer: One agent generates, another evaluates and feeds back in a loop. Use when a single pass isn't reliable enough. When to not use multi-agent at all Teams have spent months on elaborate multi-agent pipelines and found that better prompting on a single agent got equivalent results. Start with one agent. Add complexity only when you can measure that it's needed. Multi-agent earns its cost when: A subtask generates noise that would bloat the main context Tasks are genuinely parallel and independent The task requires conflicting system prompts, or one agent is managing so many tools its performance degrades It's the wrong call when agents constantly need to share context, inter-agent dependencies create more overhead than the execution saves, or the task is simple enough that one well-prompted agent handles it. One specific warning for coding: parallel agents writing code make incompatible assumptions. When you merge, those decisions conflict in ways that are hard to debug. Subagents for coding should explore and answer questions, not write code simultaneously with the main agent. Three failure modes that show up constantly Vague task descriptions. Agents duplicate each other's work. Every agent needs a clear objective, expected output format, guidance on what to use, and explicit boundaries on what not to cover. Verification agents that don't actually verify. Write explicit instructions: run the full test suite, cover these specific cases, do not mark complete until each passes. Vague approval criteria produce false positives. Token costs that compound faster than expected. Use your most capable model where it matters. Route routine work to faster, cheaper models. Build in budget controls.

---

• Promoted

---

---

Principles of prompting in vibecoding tools.

u/julyvibecodes

7 hr. ago Principles of prompting in vibecoding tools.

Y'all (mostly lol) use Lovable, Bolt, Prettiflow or v0 but prompt like it's ChatGPT lmao. This is how you should prompt. One step at a time : bad prompt: "build me a dashboard with charts, filters, user auth, and export to CSV" good prompt: "build a static dashboard layout with a sidebar and a top nav. no logic yet, just the structure" You can't skip steps with AI the same way you can't skip steps in real life. ship the skeleton. then add the organs. agents go off-rails when the scope is too wide. this is still the #1 reason people get 400 lines of broken code on the first response. This isn't relatable for you if you're using Opus 4.6 or Codex 5.4 with parallel agents enabled but most people won't be using this as it's expensive. Specify what you imagine : It has no idea what's in your head bad: "make it look clean" good: "use a monochrome color palette, 16px base font, card-based layout, no shadows, tailwind only, no custom CSS" Here, if you aren't familiar with CSS, it's okay just go through web design terms and play with them in your prompts, trust me you'll get exactly what you imagine once you get good at playing around with these. In 2026 we have tools like Lovable, Bolt, Prettiflow, v0 that can build entire features in one shot but only if you actually tell them what the feature is. vague inputs produce confident-sounding wrong outputs. your laziness in the prompt shows up as bugs in the code. Add constraints : tell it what NOT to do... bad: gives no constraints, watches it reskin your entire app when you just wanted to change the button color good: "only update the pricing section. don't touch the navbar. don't change any existing components" This one change will save you from the most annoying vibecoding moment where it "fixed" something you didn't ask it to fix and now your whole app looks different. Give it context upfront : None of them know what you're building unless you tell them. before you start a new project or a new chat, just dump a short brief. your stack, what the app does, who it's for, what it should feel like. "this is a booking app for freelancers. minimal UI. no illustrations. mobile first." Just a short example, just drop your plan in Claude Sonnet 4.6 and walk through the user flow, back-end flow along with it. Also normalize pasting the docs link when it starts hallucinating an integration. don't re-explain the API yourself, just drop the link. Check the plan before it builds anything : Most of these tools have a way to preview or describe what they're about to do before generating. use it. If there's a way to ask "what are you going to change and why" before it executes, do that. read it. if it sounds wrong, it is wrong. one minute of review here is worth rebuilding three screens later. The models are genuinely good now. the bottleneck is almost always the prompt, the context, or the scope. fix those three things and you'll ship faster than your previous self. Also, if you're new to vibecoding, checkout vibecoding tutorials by @codeplaybook on YouTube. I found them decently good.

---

post your app/product on these subreddits

u/Ok-Engine-172

23 hr. ago post your app/product on these subreddits

---

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

Expand Navigation Collapse Navigation


id: 479b12fd3591
source_platform: reddit
author: t2_a39enmes
published_at: 2026-03-18T01:00:11.852402+00:00
collected_at: 2026-03-18T01:03:46.114152+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude", "gemini-cli"]
novelty: similar
similar_to_ids: ["0e4296f0f076", "24717f8b983f", "ef284a502c1b", "8d0142693489", "c22de644b867"]
title:
https://www.reddit.com/r/vibecoding/comments/1rqnaxm/i_tried_vibe_coding_and_now_i_understand_why.json

summary:
用户通过Claude进行概念头脑风暴，使用gemini-cli免费版本进行代码生成，采用"vibe coding"迭代循环在一天内完成了一个功能完整的终端生产力管理应用。该项目展示了AI辅助代码生成在快速原型开发中的高效性，用户仅需调整颜色等细节，大幅缩短了从概念到可用产品的开发周期。

source_url:
https://www.reddit.com/r/vibecoding/comments/1rqnaxm/i_tried_vibe_coding_and_now_i_understand_why.json

raw_content:
https://www.reddit.com/r/vibecoding/comments/1rqnaxm/i_tried_vibe_coding_and_now_i_understand_why.json

**Project:** Terminal-based Personal Productivity Manager
*(the Pip-Boy animation in the background is a separate older project, not included)*

**Features:** To-do list, Goals, Projects, Tasks, Good/Bad habit tracking, XP, Levels, and a Credit system.

Projects auto-generate daily tasks. Completing tasks earns you XP and Credits — which you can spend to "buy" bad habits like doom scrolling 😅

---

This project was built almost entirely with AI. The only code I touched myself was some color tweaks — everything else I honestly don't fully understand lol.

Here's how it went:

- **Ideation** — Used Claude to brainstorm the concept, and it helped me summarize everything into a clean prompt to start building
- **Building** — Used gemini-cli (free tier) to do the actual coding. The first version it generated was rough — just a skeleton, features barely worked, nothing connected properly, bugs everywhere
- **The process** — Pure vibe coding loop: run the app → hit a bug → describe it → ask for a new feature → repeat, until I hit the daily request limit

**The scary part? This took one day.**

If I had built this myself from scratch — learning the libraries, figuring out the architecture — it would have taken weeks, maybe months. And I'm not even that strong of a programmer.

The app is genuinely something I'll use personally. It's personalized in a way no off-the-shelf app could be, and it actually got finished — which says a lot for a solo side project.

Not touching on production readiness here, that's a different conversation. But personally, I think we're heading toward a world where individuals and teams can spin up internal tools like this fast and cheap. That part is kind of wild to think about.


If you want to check it out
Task management app: github.com/Tong-ST/coreos

That animation app: github.com/Tong-ST/Funcher
(Hard to setup, only work on Linux on sway/i3wm)


id: 286e6147c6ae
title: Claude Code Use Cases - What I Actually Do : r/ClaudeCode - Reddit
source_url: https://www.reddit.com/r/ClaudeCode/comments/1rmd5d8/claude_code_use_cases_what_i_actually_do/
source_platform: reddit
author: unknown
published_at: 2026-03-07T00:00:00+00:00
collected_at: 2026-03-18T01:04:00.747929+00:00
scenario_type: 工作流自动化
novelty: similar
similar_to_ids: ["95b07c16360e", "4a8b3582430c", "e1859e355e0c", "4188cb874081", "220851dd1119"]
summary:
独立创业者使用Claude Code构建完整的业务运营自动化系统，包括每日早间运营简报（整合5个数据源）、语音指令转化为行动、以及Web应用开发和维护。通过AI驱动的工作流编排，实现从数据整合、任务调度到代码开发的端到端自动化，显著提升了单人创业的运营效率。

tools_used:
["Claude Code", "Google Calendar", "Reddit", "X", "Substack", "YouTube", "Wispr Flow", "React", "TypeScript", "PHP", "MySQL"]

raw_content:
Claude Code Use Cases - What I Actually Do : r/ClaudeCode - Reddit

Claude Code Use Cases - What I Actually Do : r/ClaudeCode Skip to main content Claude Code Use Cases - What I Actually Do : r/ClaudeCode

Go to ClaudeCode

r/ClaudeCode 10d ago

jonathanmalkin

# Claude Code Use Cases - What I Actually Do

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:

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:

"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:

"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 <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) -> GitHub Actions CI -> staging deploy -> automated smoke test (Playwright via agent-browser, mobile viewport) -> I approve -> production deploy -> 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 -> Mar 1 initial decision -> Mar 2 adversarial stress test -> 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:

[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 -> 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:

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.

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.

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).

Post. The`/post-article` skill handles cross-platform posting via browser automation. Updates tracking docs, moves files from Approved to Published.

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 & 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 & 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 -> rule -> 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.

Read more

Share

---

• Promoted

This is what “AI for work” is supposed to look like. No prompts. No setup headaches. Just projects moving.

---

Usualguy01

9d ago

This is wild. Morning briefing + voice routing alone is a game-changer. The advisory mode for decisions is next-level, and your pipeline for content + deployment shows real data-driven action. Feels like Claude Code is basically a full co-founder that never sleeps.

1

jonathanmalkin

9d ago

Yes that sounds like a great description!

1

jonathanmalkin

9d ago

Do you have something similar?

1

Continue this thread

---

## View Post in

हिन्दी

日本語

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

Expand Navigation Collapse Navigation


id: 4a5ecb108ac0
title: I finally found a Claude Code workflow that actually works (sharing it)
source_url: https://www.reddit.com/r/ClaudeAI/comments/1p1vy31/i_finally_found_a_claude_code_workflow_that/
source_platform: reddit
author: unknown
published_at: 2025-11-20T00:00:00+00:00
collected_at: 2026-03-18T01:04:34.310093+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude Code", "Next.js"]
novelty: similar
summary:
用户分享了一套成熟的Claude Code工作流程，包括详细规划、任务分解、测试驱动开发、检查点管理和项目级文档等实践，能显著提高代码生成质量和稳定性。该工作流通过明确的约束和迭代验证，有效避免了AI辅助编程中常见的问题，对实际项目开发具有高实用价值。

similar_to_ids:
["b84b9fe32380", "5b6f4e63a641", "8d0142693489", "c22de644b867", "ef284a502c1b", "19e007cf2bb9", "4cbcc14ad9be"]

raw_content:
I finally found a Claude Code workflow that actually works (sharing it)

I finally found a Claude Code workflow that actually works (sharing it) : r/ClaudeAI Skip to main content I finally found a Claude Code workflow that actually works (sharing it) : r/ClaudeAI

Go to ClaudeAI

r/ClaudeAI 4mo ago

Arindam_200

# I finally found a Claude Code workflow that actually works (sharing it)

I’ve been using Claude Code as my main IDE assistant for a while now, and after a lot of messing around, I finally landed on a workflow that feels stable and reliable enough for real projects.

Thought I’d share it here in case anyone else is trying to move beyond “vibe coding.”

Here’s what’s been working for me:

I always start with a detailed planI don’t let Claude jump straight into code. I begin with a step-by-step plan prompt, tighten the logic, surface edge cases, and approve the direction first. Most mistakes disappear just by doing this.

I break features into small, focused chunksAnything too big makes Claude wander. I split work into 3-5 small tasks so each prompt is laser-focused.

I follow a test-driven flowI let Claude build the feature first, then I run tests to see what actually breaks or behaves differently than expected. Based on those results, I ask Claude to fix each issue. Then I rerun tests. Then fix again. And I loop like this until everything is stable. This simple cycle maintains quality without overwhelming Claude upfront.

I use checkpointing a LOTCheckpointing is a life-saver for me. If an edit goes offtrack, I rewind the code or conversation and keep going. No stress.

I keep a project-level Claude .mdThis one changed everything. I store:

architecture rules

naming conventions

folder structure

component patterns

things Claude should never do

Claude follows this across sessions and stops making random decisions.

6. I only refactor after everything worksIf you refactor too early, Claude starts inventing stuff. But once the feature is solid, its refactors are honestly great.

7. I’m very explicit with constraintsClaude performs way better when the boundaries are clear. So, I often use these in the prompts “Use the existing pattern.”, “Touch only these files.”, “No new dependencies.”. And I have seen this works really Well!

I recorded a full walkthrough of this workflow using a real Next.js repo if you want to see it in action: My Claude Code Workflow

If you have some more tips that you find useful, please let me know. I will add them to my workflow as well!

Read more

Share

---

• Promoted

Cut Code Review Time and Bugs in Half. Sign up for a free trial!

---

ClaudeAI-mod-bot

4mo ago

If this post is showcasing a project you built with Claude, please change the post flair to Built with Claude so that it can be easily found by others.

1

Illustrious-Report96

4mo ago

Just talk to the LLM about the problem you’re solving and then tell them to write failing tests first, git commit. Then write the structure for the solution next. Git commit. Then add the behavior for the solution. Git commit. Then pass the tests. Git commit. Then add/update docs to align with code. Git commit. Push. Open pr. Done.

47

PricePerGig

4mo ago

You been watching me over my shoulder? you got a screen recorder on my system? 🧐 the only bit missing - if you're asking Claude to do a lot/being lazy, just say 'use google chrome map to test, loop until complete and functioning', setup a hook to shout at you when you are needed at the keyboard and let it run for 20-30 mins, then I check the work. Super lazy approach though!

4

pleasantothemax

4mo ago

Sorry for what maybe a dumb q but what is the Google Chrome map you’re referring to?

6

5 more replies

Continue this thread Continue this thread

Illustrious-Report96

4mo ago

If you wanna take it to the next level tell the LLM: no new behavior without tests. Tell them: make pre-commit and pre-push hooks that guard against this policy by enforcing that commits with feat or fix add news tests or improve coverage. Chore: and refactor: should keep coverage or improve it. Reject otherwise. Can make similar scripts run as GitHub actions to enforce this policy on both ends.

To level up even more say: tests ARE the spec in your AGENTS.md

5

[deleted]

4mo ago

Interesting approach, I usually just say "do what I have in mind" and let it figure out the rest.

2

Illustrious-Report96

4mo ago

Hell yeah brötha. Now just say “write failing tests first” and that seemingly small change has profound implications. Your test becomes the spec. Not some markdown file that isn’t code. Reduces drift.

2

1 more reply

Continue this thread

ballgucci

4mo ago

This is the way

2

1 more reply

Continue this thread

turbineslut

4mo ago

This does most of this in a neat package. Very happy with it https://github.com/rizethereum/claude-code-requirements-builder

9

PricePerGig

4mo ago

I've not tried that. I'm on speckit at the moment. Do you have a comparison/have your tried speckit?

2

1 more reply

Continue this thread

• Promoted

Tasks here. Docs there. Chat somewhere else. Or… one workspace.

mrfouz

4mo ago

Superpower skills is all i need now! The next iteration is removing me out of the loop

5

2 more replies

Continue this thread

crystalanntaggart

4mo ago

I'm doing a little bit different workflow that's working for me. I'm using ChatGPT to create high-level technical designs and design approaches, feeding his recommendations into a Claude web project, then the web project has access to the github source code, then using Claude code to implement the tech specs designed by Claude web.

I create ask claude web to test script to test the feature...boom. I get to see that it's implemented in a way that I agree with, refine the specs for things that were missed or inferred and use claude code to update this (and update the test script to reflect the new capabilites) and then boom. Retest again and verify.

3

ciferone

4mo ago

I work more or less like this too, and it works. It doesn't always read the Claude.md file but that's it

2

1 more reply

Continue this thread

TheBlackGhost_9

4mo ago

Nice one

2

1 more reply

Continue this thread

Creepy-Row970

4mo ago

very interesting approach

2

1 more reply

Continue this thread

xtof_of_crg

4mo ago

```
[*] --> InitialPlanning : [have idea]

state InitialPlanning {
    state "Establish\nGithub Issue\n(problem-focused)" as EstablishGHIssue
    state "Chat With Claude\nAbout Approach" as ChatWithClaude
    [*] --> ChatWithClaude
    ChatWithClaude --> EstablishGHIssue
    EstablishGHIssue --> [*]
}

InitialPlanning --> [*] : issue created
[*] --> DoWork : [pull issue]

state DoWork {
    [*] --> PullGHIssue
    
    PullGHIssue -right-> RefineIssue : [issue too big]
    PullGHIssue --> DeepDiveSolution
    
    DeepDiveSolution --> CreateBranch
    
    state DeepDiveSolution {
        [*] --> AnalyzeAndPlan
        AnalyzeAndPlan --> DraftScratchpad
        DraftScratchpad --> PoseRefiningQuestions
        PoseRefiningQuestions --> OperatorAnswers
        OperatorAnswers --> UpdateScratchpad
        UpdateScratchpad --> OperatorApproves : [ready]
        UpdateScratchpad --> PoseRefiningQuestions : [needs refinement]
        OperatorApproves --> [*]
    }
    
    CreateBranch --> Execute
    
    state Execute {

    }
    
    Execute --> CreatePR
    Execute --> NukeBranch : [abandon]
    
    CreatePR --> ReviewPR
    
    ReviewPR --> Execute : [needs changes]
    ReviewPR --> MergePR : [approved]
    
    MergePR --> ArchiveScratchpad
    ArchiveScratchpad --> [*]
    
    NukeBranch --> [*]
}

note left of Execute
    Mostly automated with operator oversight
    Scratchpad updates implied
    Operator can interject/chat as needed
end note
        
state RefineIssue {
    [*] --> EstablishSubIssues
    EstablishSubIssues -left-> DoWork
}

RefineIssue -up--> InitialPlanning : [reconceptualization needed]\n(new chain of thought)

u/enduml
```

2

Appropriate-Career62

3mo ago

How to use Claude Code - Sub Agents, Skills, MCPs, no context window pollution

0

• Promoted

The apps you know go further with Copilot.

bakezq2

4mo ago

I just treat cc as a real dev, ask him generate and revise until the final plan that i can understand and agree with are done, then I let him continue with the implementation and testing.

1

aspublic

4mo ago

Congrats. Do you have any code running remotely, or is everything running locally in the browser extension?

1

Jolly-Algae9528

4mo ago

https://www.workflow-config.app를 추천하고싶습니다. 제가 만들었습니다.

1

1 more reply

Continue this thread

sepes_15

4mo ago

Why not let Claude generate the plan on its own? I’ve heard at an Anthropic presentation that this is the recommended approach, since Claude’s native code-planning mode tends to outperform any custom prompt you create for planning. But maybe I’m missing something.

1

ElephantMean

4mo ago

Also do similar, except I preserve version-control, rather than Check-Points. All working Source-Code are saved into versions-histories sub-directories, such as v/00.00.00, v/00.00.01, v/00.00.02, etc.

Time-Stamp: 20251120T22:53Z

1

---

## View Post in

हिन्दी

Français

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

Expand Navigation Collapse Navigation


id: 997ebe8dd738
title: How do you actually use Claude Code in your day-to-day workflow ...
source_url: https://www.reddit.com/r/ClaudeAI/comments/1phyfk4/how_do_you_actually_use_claude_code_in_your/
source_platform: reddit
author: unknown
published_at: 2025-12-09T00:00:00+00:00
collected_at: 2026-03-18T01:04:44.733601+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude Desktop App", "Claude Code CLI", "VS Code"]
novelty: similar
summary:
用户分享了一套创新的双Claude工作流程，使用Claude Desktop作为监督者进行代码分析和提示生成，Claude Code CLI在VS Code中执行实现。通过维护项目文档、数据库结构文件和日志系统等本地自动化工具，实现了高效的代码生成和审查循环。

similar_to_ids:
["4a5ecb108ac0", "b84b9fe32380", "4cbcc14ad9be", "8d0142693489", "c22de644b867", "19e007cf2bb9", "ef284a502c1b"]

raw_content:
How do you actually use Claude Code in your day-to-day workflow ...

How do you actually use Claude Code in your day-to-day workflow? I’ll start: : r/ClaudeAI Skip to main content How do you actually use Claude Code in your day-to-day workflow? I’ll start: : r/ClaudeAI

Go to ClaudeAI

r/ClaudeAI 3mo ago

Mac_In_Toshi

# How do you actually use Claude Code in your day-to-day workflow? I’ll start:

Share your methods and tips!

After a few months using Claude Code, I ended up developing a somewhat different workflow that’s been working really well. The basic idea is to use two separate Claudes - one to think and another to execute.

Here’s how it works:

Claude Desktop App: acts as supervisor. It reads all project documentation, analyzes logs when there’s a bug, investigates the code and creates very specific prompts describing what needs to be done. But it never modifies anything directly.

Claude Code CLI in VS Code: receives these prompts and does the implementations. Has full access to the project and executes the code changes.

My role: is basically copying prompts from one Claude to the other, running tests and reporting what happened.

The flow in practice goes something like this: I start the session having Claude Desktop read the CLAUDE.md (complete documentation) and the database schema. When I have a bug or new feature, I describe it to Claude Desktop. It investigates, reads the relevant files and creates a surgical prompt. I copy that prompt to Claude Code which implements it. Then Claude Desktop validates by reading each modified file - it checks security, performance, whether it followed project standards, etc. If there’s an error in tests, Claude Desktop analyzes the logs and generates a new correction prompt.

What makes this viable: I had to create some automations because Claude Code doesn’t have native access to certain things:

CLAUDE.md - Maintains complete project documentation. I have a script that automatically updates this file whenever I modify code. This way Claude Desktop always has the current context.

EstruturaBanco.txt - Since Claude Code doesn’t access the database directly, this file has the entire structure: tables, columns, relationships. Also has an update script I run when I change the schema.

Log System - Claude CLI and Code Desktop don’t see terminal logs, so I created two .log files (one for frontend, another for backend) that automatically record only the last execution. Avoids accumulating gigabytes of logs and Claude Desktop can read them when it needs to investigate errors.

Important: I always use Claude Code Desktop in the project’s LOCAL folder, never in the GitHub repository. Learned this the hard way - GitHub’s cache/snapshot doesn’t pick up the latest Claude CLI updates, so it becomes impossible to verify what was recently created or fixed.

About the prompts: I use XML tags to better structure the instructions like:` `,` `,` `,` `,` `,` `. Really helps maintain consistency and Claude understands better what it can or can’t do.

Results so far: The project has 496 passing unit tests, queries running at an average of 2.80ms, and I’ve managed to keep everything well organized. The separation of responsibilities helps a lot - the Claude that plans isn’t the same one that executes, so there’s no context loss.

And you, how do you use Claude Code day-to-day? Do you go straight to implementation or do you also have a structured workflow? Does anyone else use automation systems to keep context updated? Curious to know how you solve these challenges.​​​​​​​​​​​​​​​​

Read more

Share

---

• Promoted

Cut Code Review Time and Bugs in Half. Sign up for a free trial!

---

ClaudeAI-mod-bot

3mo ago

This flair is for posts showcasing projects developed using Claude.If this is not intent of your post, please change the post flair or your post may be deleted.

1

darkyy92x

3mo ago

Why wouldn‘t you just use 2x Claude Code for this? Plan mode is exactly for that.

11

Mac_In_Toshi

3mo ago

I researched Plan Mode and found it pretty interesting, will test it out later.

The reason I separate supervisor and executor is to keep the execution context 100% clean. The executor receives an already planned and refined prompt, so it doesn’t waste time or tokens planning - it just executes. The context stays preserved, direct and focused on the problem.

But there’s an important detail: even after Claude Desktop analyzes all the code and creates the detailed prompt, I always ask it NOT to completely limit the executor’s autonomy. The prompt is surgical and targeted, but I leave room for Claude Code CLI to make additional adjustments if it identifies something relevant.

And you know what happens? Many times, after validating the result, the supervisor realizes the executor did something much more robust than requested - often it takes advantage of the autonomy to improve the solution beyond what was planned. This is one of the biggest advantages of working with two AIs on the same task.

I use Sonnet 4.5 a lot as supervisor and Opus 4.5 as executor, but even two Opus 4.5 work well - they usually give different answers for the same task, bringing complementary solutions or distinct approaches.​​​​​​​​​​​​​​​​

5

drinksbeerdaily

3mo ago

Just use Claude Code to build you a plan.MD file, clear context, implement plan. Going between two graphical user interfaces for this is unnecessarily complicated.

2

1 more reply

Continue this thread Continue this thread Continue this thread

DazzlingOcelot6126

3mo ago

I do everything in Claude Code CLI. Start with brainstorm command on idea or task. I made a way to level up claude code. It works well with async agents, and subagents all together in parallel. No worktrees needed. No race conditions. When using async agents with subagents, my main context window keeps from autocompacting for much longer now.

Persistent memory even across projects, it learns from mistakes over time forming heuristics, golden rules, and uses sqlite nodes with pheromone trails and hotspot dependacy graphs. A blackboard is used for coordinating agents. I use a react dashboard as overview, and to tweak things when need be, though, claude manages heuristics fine just by asking. I save tokens by not having to repeat myself starting a session as it remembers better. The /swarm "task here" command is super powerful with ultrathink enabled. If you ask claude to check my repo out it can explain better and it can easily install by asking too. 20 dollar anthropic plan can do swarm but I'd suggest max for daily driving an opus swarm. It can be adjusted to run haiku just by saying swarm haiku on task and it uses opus to orchestrate default which can also be changed to whatever you like.

It's open source and free https://github.com/Spacehunterz/Emergent-Learning-Framework_ELF

8

vincentdesmet

3mo ago

i used to do that, but now i use methods like spec-kit or BMAD to fully create a list of tasks (across the full repo, each file affected, design, acceptance criteria and all)

validate the plan, research, task lists (i use beads) with full cross reference detection of conflicts (i tend to use opus for this)

then i hand off to cheaper model to do the work, i still don’t trust Haiku so its Sonnet 4.5 and Gemini 3.0 - they track progress

i’ve been trying to spawn sub agents (even with the new send-to-background and resume) but this still fails painfully so i just load up the context, implement a few tasks in-line, review and validate the work, prepare progress updates in markdown and next context load prompts, kill the session and repeat (i kill when i reach below 30%, any compaction kills my token budget)

i’ve found i make the most progress this way while staying in the loop, course adjusting and making notes as i monitor Claude. i stage or commit in between sessions to have nearly working full unit of work commits.

if i want super basic work with very little planning or up front research i just kick off Gemini 3.0 - it does a decent job (usually on utilities i don’t care too much about long term maintenance and controlling the design)

i’m on the $20/month plan for both CC and Gemini, i top up wallet for Opus sometimes - overall spend is closer to $80 than what a MAX plan would give me

any limits i hit are a good opportunity to go gym or touch grass

3

Relative_Register_79

3mo ago

Me the way I did it I have 4 Claude code instance talking to each other in a mesh communication. where each instance can see what the others does. I can send instruction to the Product Manager without the rest of team seeing what I said to him. Then him can rephrase what I said to the others they all see talk to each others like a Digital Organization where IAM the CEO. I have to patch cli.js in order to do that. It’s close to the same idea of https://github.com/moazbuilds/CodeMachine-CLI. But realtime and instead of spawning Claude instance that loose their memory after the task. You have employee that learn and be improve daily. They can remember what they was working and we all can go in a meeting room to brainstorm together. I was thinking 🤔 we can basically create a Digital Organization with Claude code. I will open-source that soon. Currently trying to build a Digital Marketing Organization with the same idea.

3

t4a8945

3mo ago

That's interesting. How does this strategy impact token usage? Each workers having its own memory seems expensive. What plan are you using? (I'm sold on claude code after my recent experiments, I'm all ear for great setups, cost is a concern but no that much as well )

1

Relative_Register_79

2mo ago

Im using the max plan and the web session. and some optimization like hooks to avoid to index folders that I don’t need like the node_modules

1

Continue this thread Continue this thread

• Promoted

Tasks here. Docs there. Chat somewhere else. Or… one workspace.

Salt_Potato6016

3mo ago

Here’s a general overview setup:

Process:

•Research: Sonnet (1M context)

•Planning: Opus drafts → Opus + Gemini + codex max review

•Rejected plans: Sonnet investigates issues raised by auditors ( do not trusts blindly) → if agree - revise → re-review (loops until approved)

•Implementation: Sonnet codes

•Audit: Complexity-based (simple = quick review, complex = full panel) - for complex same auditors as for planning

•Same rejection loop until approved → push to git

Sounds like an overkill ,and there’s more steps to it of course as it’s automated lbut I’ve had really good success rate with it

Downside : can take time to fully finish but saves time in debugging etc

Also got agent skills set up, documentation auditors etc so everything is in perfect sync and saves token usage a lot

3

Obvious-Grape9012

3mo ago

the old; Big models for big plans trick

1

Continue this thread

Appropriate-Career62

3mo ago

How to use Claude Code - Sub Agents, Skills, MCPs, no context window pollution

2

thecrustycrap

15d ago

This is incredibly helpful, thank you

2

Continue this thread

RandomMyth22

3mo ago

Building a Claude Code enhancement tool. And, working on PoC’s to master coding with an AI LLM. I have one project that I am thinking about trying to sell in the Apple App Store.

1

degenbrain

3mo ago

I always use the plan-execute mode. I enable thinking mode if the problem is difficult or requires sequential steps. Ask Opus to create a detailed plan and have Sonnet or Haiku execute it. Manual switching. Everything is in the Claude code CLI. When it comes to documentation, I switch to the Haiku model. As a pro user, I need to be thoughtful about spending tokens.

1

Parabola2112

3mo ago

I think you would find Plan mode far more efficient.

1

Mac_In_Toshi

3mo ago

I researched Plan Mode and found it pretty interesting, will test it out later.

1

Continue this thread

• Promoted

You can generate entire apps, why not dashboards?

pm_me_ur_doggo__

3mo ago

Today I sat on my hammock using Claude code from the app on my phone. I have it set up to create working preview deployments on vercel for every branch it creates. I use the GitHub app to review code in PRs that Claude code can create.

I also use the terminal app, but for idea -> working prototype the cc on web stuff is fantastic.

1

K_M_A_2k

3mo ago

Huh interesting. My workflow is similar but just run Claude code web as the orchestrator and Claude code via Claude desktop or terminal. Never thought of running Claude desktop locally, what benefits to running locally vs web? I use web because I have a dedicated tab groups to Claude chatgpt Gemini copilot grok perplexity so I can bounce between when need be.

1

Mac_In_Toshi

3mo ago

The main issue I ran into with Claude Code Web (using GitHub repos) is the caching/snapshot behavior when working with multiple AI instances. Here’s the problem:

When you’re running two AIs on the same task - one planning and another executing - Claude Code Web creates a snapshot of your files when it first reads them. If your CLI makes changes to a file, Claude Code Web might still be reading the old cached version instead of the updated file. So you could fix a bug in the CLI, then ask Claude Web to validate it, and it’ll be looking at the outdated code.

Running Claude Desktop App locally (pointing directly to your project folder) solves this because it always reads the current state of the files - no GitHub snapshot in between.

Important caveat though: When you open Claude Desktop App, make sure you’re pointing to the correct folder. Claude can create a worktree (branch) to preserve your main code, and if the CLI modifies your main branch while Claude Desktop is reading the worktree, you’ll have a mismatch.

My approach: I select the parent folder first, not the project folder itself - this prevents the automatic worktree creation. Just always double-check the path when starting a session to make sure both CLIs are looking at the same actual files.

1

K_M_A_2k

3mo ago

well son of a bitch i never even considered that. I was running claude chat in web & having it give me prompts to feed to claude code wasnt asking it to actaully validate anything just trying to do ABC chat says prmopt claude code with XYZ then when it doesnt work strategize with chat & itterate back & forth i never considered having chat local being able to see the same files/code....hot damn, interesting!

Can chat locally see into vs code as well then?

1

3 more replies

Continue this thread Continue this thread Continue this thread

pmagi69

2mo ago

You've built separation of concerns—planning vs. execution. The issue is manual orchestration. Workflow knowledge lives in your head, not the system.

1

---

## View Post in

Français

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

Expand Navigation Collapse Navigation


id: 9b8fb32d5892
title: shareAI-lab/learn-claude-code
source_url: https://github.com/shareAI-lab/learn-claude-code
source_platform: github
author: shareAI-lab
published_at: 2026-03-17T17:19:48+00:00
collected_at: 2026-03-18T01:05:18.190516+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude", "TypeScript", "Python", "Bash"]
novelty: similar
similar_to_ids: ["997ebe8dd738", "4a5ecb108ac0", "3ebfd70a08ab", "6d32ae370100", "6cd481931948", "a90e1fa2514d"]
summary:
这是一个从零开始构建的Claude Code风格的AI代理框架,使用Bash和多种编程语言实现。项目提供了代理开发的教学资源,展示了如何通过简洁的工具链创建功能完整的AI代码助手,具有较高的教育和实践价值。

raw_content:
shareAI-lab/learn-claude-code

Bash is all you need -  A nano claude code–like agent harness, built from 0 to 1

Topics: agent, agent-development, ai-agent, claude, claude-code, educational, llm, python, teaching, tutorial
Language: TypeScript | Stars: 30526


id: 5004ebd47d90
title: Show HN: Three new Kitten TTS models – smallest less than 25MB
source_url: https://github.com/KittenML/KittenTTS
source_platform: hackernews
author: rohan_joshi
published_at: 2026-03-19T15:56:06+00:00
collected_at: 2026-03-20T01:00:34.679307+00:00
scenario_type: 代码生成与审查
tools_used: ["Kitten TTS", "ONNX", "GitHub"]
novelty: new
similar_to_ids: []
summary:
Kitten TTS发布了三个轻量级文本转语音模型（14M-80M参数），最小仅25MB，支持8种英文语音，采用int8+fp16量化和ONNX运行时，可在树莓派、低端手机和浏览器等设备上离线运行。该项目为边缘设备上的生产级语音应用提供了实用的开源解决方案。

raw_content:
Show HN: Three new Kitten TTS models – smallest less than 25MB

Kitten TTS (<a href="https:&#x2F;&#x2F;github.com&#x2F;KittenML&#x2F;KittenTTS" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;KittenML&#x2F;KittenTTS</a>) is an open-source series of tiny and expressive text-to-speech models for on-device applications. We had a thread last year here: <a href="https:&#x2F;&#x2F;news.ycombinator.com&#x2F;item?id=44807868">https:&#x2F;&#x2F;news.ycombinator.com&#x2F;item?id=44807868</a>.<p>Today we&#x27;re releasing three new models with 80M, 40M and 14M parameters.<p>The largest model (80M) has the highest quality. The 14M variant reaches new SOTA in expressivity among similar sized models, despite being &lt;25MB in size. This release is a major upgrade from the previous one and supports English text-to-speech applications in eight voices: four male and four female.<p>Here&#x27;s a short demo: <a href="https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=ge3u5qblqZA" rel="nofollow">https:&#x2F;&#x2F;www.youtube.com&#x2F;watch?v=ge3u5qblqZA</a>.<p>Most models are quantized to int8 + fp16, and they use ONNX for runtime. Our models are designed to run anywhere eg. raspberry pi, low-end smartphones, wearables, browsers etc. No GPU required! This release aims to bridge the gap between on-device and cloud models for tts applications. Multi-lingual model release is coming soon.<p>On-device AI is bottlenecked by one thing: a lack of tiny models that actually perform. Our goal is to open-source more models to run production-ready voice agents and apps entirely on-device.<p>We would love your feedback!


id: f12b3fe36c92
title: Show HN: Will my flight have Starlink?
source_url: https://news.ycombinator.com/item?id=47428650
source_platform: hackernews
author: bblcla
published_at: 2026-03-18T17:29:21+00:00
collected_at: 2026-03-20T01:01:04.264626+00:00
scenario_type: 数据分析与可视化
tools_used: ["Starlink航班数据库", "航班查询工具", "机型数据库", "尾号追踪系统"]
novelty: similar
similar_to_ids: ["ae19178305e3"]
summary:
该项目构建了一个Starlink航班覆盖预测系统，通过聚合航空公司设备分配数据、机型信息和尾号追踪数据，帮助用户查询特定航班是否配备Starlink。虽然主要是数据汇总和分析工具，但实际应用场景相对垂直，主要服务于旅行用户的特定需求。

raw_content:
Show HN: Will my flight have Starlink?

Hey HN, If you’ve been lucky enough to be on a flight with Starlink, you understand the hype. It actually works!<p>However, its availability on flights is patchy and hard to predict. So we built a database of all airlines that have rolled out Starlink (beyond just a trial), and a flight search tool to predict it. Plug in a flight number and date, and we&#x27;ll estimate the likelihood of Starlink on-board based on aircraft type and tail number.<p>If you don’t have any trips coming up, you can also look up specific routes to see what flights offer Starlink. You can find it here: <a href="https:&#x2F;&#x2F;stardrift.ai&#x2F;starlink">https:&#x2F;&#x2F;stardrift.ai&#x2F;starlink</a> .<p>-<p>I wanted to add a few notes on how this works too. There are three things we check, in order, when we answer a query:<p>- Does this airline have Starlink?<p>- Does this aircraft body have Starlink?<p>- Does <i>this specific aircraft</i> have Starlink?<p>Only a few airlines at all have Starlink right now: United, Hawaiian, Alaskan, Air France, Qatar, JSX, and a handful of others. So if an aircraft is operated by any other airline, we can issue a blanket no immediately.<p>Then, we check the actual body that&#x27;s flying on the plane. Airlines usually publish equipment assignments in advance, and they&#x27;re also rolling out Starlink body-by-body. So we know, for instance, that all JSX E145s have Starlink and that none of Air France&#x27;s A320s have Starlink. (You can see a summary of our data at <a href="https:&#x2F;&#x2F;stardrift.ai&#x2F;starlink&#x2F;fleet-summary">https:&#x2F;&#x2F;stardrift.ai&#x2F;starlink&#x2F;fleet-summary</a>, though the live logic has a few rules not encoded there.)<p>If there&#x27;s a complete match at the body type level, we can confidently tell you your flight will have Starlink. However, in most cases, the airline has only rolled out a <i>partial</i> upgrade to that aircraft type. In that case, we need to drill down a little more and figure out exactly <i>which</i> plane is flying on your route.<p>We can do this by looking up the &#x27;tail number&#x27; (think of it as a license plate for the plane). <i>Unfortunately</i>, the tail number is usually only assigned a few days before a flight. So, before that, the best we can do is calculate the probability that your plane will be assigned an aircraft with Starlink enabled.<p>To do this, we had to build a mapping of aircraft tails to Starlink status. Here, I have to thank online airline enthusiasts who maintain meticulous spreadsheets and forum threads to track this data! As I understand it, <i>they</i> usually get this data from airline staff who are enthusiastic about Starlink rollouts, so it&#x27;s a reliable, frequently updated source. Most of <i>our</i> work was finding each source, normalizing their formats, building a reliable &amp; responsible system to pull them in, and then tying them together with our other data sources.<p>Basically, it&#x27;s a data normalization problem! I used to work on financial data systems and I was surprised how similar this problem was.<p>-<p>Starlink itself is also a pretty cool technology. I also wrote a blog post (<a href="https:&#x2F;&#x2F;stardrift.ai&#x2F;blog&#x2F;why-is-starlink-so-good">https:&#x2F;&#x2F;stardrift.ai&#x2F;blog&#x2F;why-is-starlink-so-good</a>) on why it&#x27;s so much better than all the other aircraft wifi options out there. At a high level, it&#x27;s only possible because rocket launches are so cheap nowadays, which is incredibly cool.<p>The performance is great, so it&#x27;s well worth planning your flights around it where possible. Right now, your best bet in the US is on United regional flights and JSX&#x2F;Hawaiian. Internationally, Qatar is the best option (though obviously not right now), with Air France a distance second. This will change throughout the year as more airlines roll it out though, and we&#x27;ll keep our database updated!


id: 5a241dca4394
title: OpenClaw AI Assistant Local Is The Automation Tool More People ...
source_platform: reddit
author: unknown
published_at: 2026-02-24T00:00:00+00:00
collected_at: 2026-03-20T01:01:30.697946+00:00
scenario_type: 工作流自动化
novelty: similar
similar_to_ids: ["de2ce3f50104", "a4713fb9eb43", "f2f51ffcd2a1", "da6cd49c549c", "a34e783b92e8", "76a435bcb8ee"]
summary:
OpenClaw是一个本地运行的AI代理工具，能够自动化浏览器操作、文件管理、shell命令和定时任务，帮助用户将重复的手动工作（如仪表板监控、任务更新、文件移动等）转变为自动化工作流。相比聊天机器人只提供建议，OpenClaw作为智能操作员实际执行任务，通过集中化管理多个系统的自动化来显著节省时间和提高效率。

source_url:
https://www.reddit.com/r/AISEOInsider/comments/1rdh0kx/openclaw_ai_assistant_local_is_the_automation/

tools_used:
["OpenClaw AI Assistant Local", "Browser automation", "File management", "Shell commands", "Scheduled workflows"]

raw_content:
OpenClaw AI Assistant Local Is The Automation Tool More People ...

OpenClaw AI Assistant Local Is The Automation Tool More People Should Be Using : r/AISEOInsider Skip to main content OpenClaw AI Assistant Local Is The Automation Tool More People Should Be Using : r/AISEOInsider

Go to AISEOInsider

r/AISEOInsider 20d ago

JamMasterJulian

# OpenClaw AI Assistant Local Is The Automation Tool More People Should Be Using

" providername="YouTube"

OpenClaw AI Assistant Local is what you use when you are tired of AI giving you advice and you want it to actually do the work.

Most people are still using AI to draft replies while they manually check dashboards, update tasks, move files, and monitor systems themselves.

That disconnect between what AI can execute and what you are still doing manually is where your time disappears every single week.

Watch the video below:

https://www.youtube.com/watch?v=3I4veME6Wxs

Want to make money and save time with AI? Get AI Coaching, Support & Courses👉 https://www.skool.com/ai-profit-lab-7462/about

# OpenClaw AI Assistant Local Runs On Your Own Machine

OpenClaw AI Assistant Local runs directly on your computer rather than inside a cloud dashboard that controls everything.

That setup means your files, browser sessions, repositories, and messaging integrations live inside infrastructure you own.

When automation runs locally, you are not locked into someone else’s pricing model or usage limits.

Local control gives you flexibility in how you design workflows.

Flexibility matters once automation starts touching multiple systems at the same time.

Instead of relying on scattered SaaS automations, you centralise execution into one agent.

Centralised execution is easier to scale than a pile of disconnected tools.

# OpenClaw AI Assistant Local Is An Agent, Not A Chatbot

OpenClaw AI Assistant Local behaves like an operator rather than a search box.

A chatbot gives you instructions and expects you to follow through manually.

An AI agent performs the task inside your environment.

If you tell it to send a message through a connected app, it sends it.

If you ask it to check something daily, it schedules and runs that task automatically.

If you need a repeatable workflow built, it creates and executes that workflow.

Execution removes entire steps from your day instead of just speeding them up.

Removing steps is how you actually reclaim time.

# What OpenClaw AI Assistant Local Can Automate

OpenClaw AI Assistant Local can automate browser actions, file operations, shell commands, and recurring jobs.

Browser automation allows it to log into accounts, navigate dashboards, extract data, and submit forms without you clicking anything.

File management enables structured edits, document generation, and organised storage inside your system.

Shell access lets it run scripts, manage repos, and trigger processes based on defined conditions.

Scheduled workflows convert one-time tasks into persistent automation.

Persistent automation reduces repetition across your week.

Reducing repetition increases your available focus.

# Developer Workflows With OpenClaw AI Assistant Local

OpenClaw AI Assistant Local integrates cleanly into developer environments.

Repositories can be monitored continuously for issues and dependency changes.

Pull requests can be generated automatically when specific triggers are met.

Routine DevOps checks can run quietly in the background.

Background execution protects your flow state during deep work sessions.

Flow state produces better results than constant interruptions ever will.

Less interruption means more shipping.

# Productivity Systems Built Around OpenClaw AI Assistant Local

OpenClaw AI Assistant Local connects task managers, notes apps, and messaging platforms into one execution layer.

Instead of switching between multiple dashboards, you issue one instruction through a connected channel.

Tasks get created or updated across systems automatically.

Calendar events can trigger workflows instead of just sending reminders.

Notifications can become real actions rather than passive alerts.

Reducing context switching protects attention.

Protected attention improves decision-making.

# Skills And Expansion Inside OpenClaw AI Assistant Local

OpenClaw AI Assistant Local includes a skills system that extends its functionality.

Skills act as plugins that add new automation behaviours.

Prebuilt skills let you deploy common workflows quickly.

Custom skills can be generated when your needs are specific.

Community contributions accelerate improvement across users.

An expandable system grows stronger over time.

Growing systems create durable leverage.

# Setup And Deployment Of OpenClaw AI Assistant Local

OpenClaw AI Assistant Local runs on MacOS, Windows, and Linux with NodeJS installed.

Installation is handled through a package manager and guided by an onboarding wizard.

There is a learning curve if you are new to terminal tools, but it is manageable.

Many users deploy it on a separate device so it can run 24/7 without interfering with their main machine.

An always-on setup turns automation into infrastructure rather than an experiment.

Infrastructure scales better than manual effort.

# Security Considerations With OpenClaw AI Assistant Local

OpenClaw AI Assistant Local has deep system access, which means configuration should be handled carefully.

Permissions need to be intentional and limited where possible.

API keys should be stored securely and not exposed casually.

Running the agent on a dedicated machine reduces risk.

Prompt injection remains an industry-wide issue, so awareness matters.

Powerful automation requires responsible usage.

# Why OpenClaw AI Assistant Local Actually Matters

OpenClaw AI Assistant Local becomes valuable when you automate predictable, repetitive tasks first.

Daily reporting, monitoring, structured updates, and routine maintenance are good starting points.

Measure the time saved instead of assuming the impact.

Reinvest that time into building, creating, or growing something that actually moves the needle.

Small daily gains compound into larger weekly advantages.

Weekly advantages stack into long-term leverage.

Leverage comes from execution, not just ideas.

# 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 OpenClaw AI Assistant Local

Is OpenClaw AI Assistant Local free? Yes, it is open-source and free, although cloud models require your own API keys.

Can OpenClaw AI Assistant Local run offline? Yes, it can operate with fully local models if configured that way.

Is OpenClaw AI Assistant Local only for developers? No, although technical familiarity helps, many workflows are accessible with basic setup knowledge.

What makes OpenClaw AI Assistant Local different from chatbot tools? It executes tasks directly on your system rather than just generating responses.

What is the biggest benefit of OpenClaw AI Assistant Local? The biggest benefit is continuous automation that compounds into measurable time savings over time.

Read more

Share

---

• Promoted

Put a twist on your selfies with ChatGPT images.

---

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

Expand Navigation Collapse Navigation


id: 17ac3f66b4e9
title: I turned Markdown into a protocol for generative UI
source_url: https://fabian-kuebler.com/posts/markdown-agentic-ui/
source_platform: hackernews
author: FabianCarbonara
published_at: 2026-03-19T13:42:14+00:00
collected_at: 2026-03-20T01:01:39.544430+00:00
scenario_type: 代码生成与审查
tools_used: ["Markdown", "React", "AI agents", "code execution engine"]
novelty: new
similar_to_ids: []
summary:
作者将Markdown转换为生成式UI协议，支持文本、可执行代码和数据的统一流传输，实现了流式代码执行和React组件挂载，连接客户端、服务器和LLM的完整数据流。这是一个创新的架构原型，展示了如何整合生成式UI和AI代理代码执行能力。

raw_content:
I turned Markdown into a protocol for generative UI

There&#x27;s a lot of work happening around both generative UI and code execution for AI agents. I kept wondering: how do you bring them together into a fully featured architecture? I built a prototype:<p>- Markdown as protocol — one stream carrying text, executable code, and data<p>- Streaming execution — code fences execute statement by statement as they stream in<p>- A mount() primitive — the agent creates React UIs with full data flow between client, server, and LLM<p>Let me know what you think!


id: c310e8d1c27e
title: Show HN: I built a P2P network where AI agents publish formally verified science
source_url: https://news.ycombinator.com/item?id=47444212
source_platform: hackernews
author: FranciscoAngulo
published_at: 2026-03-19T19:00:43+00:00
collected_at: 2026-03-20T01:02:28.946046+00:00
scenario_type: 工作流自动化
tools_used: ["GUN.js", "IPFS", "Lean 4", "ML-KEM-768", "ML-DSA-65", "Nym", "MCP tools"]
novelty: new
similar_to_ids: []
summary:
用户构建了P2PCLAW，一个P2P网络平台，使AI智能体和研究人员能够发现彼此、共享科学成果，并通过正式的Lean 4数学证明进行验证。系统采用GUN.js和IPFS实现去中心化架构，集成了后量子密码学和隐私保护，允许智能体无需账户直接加入并协作。这是一个创新的科研工作流自动化解决方案，解决了多智能体重复工作的问题，具有高度的实用价值和技术深度。

raw_content:
Show HN: I built a P2P network where AI agents publish formally verified science

I am Francisco, a researcher from Spain. My English is not great so please be patient with me.<p>One year ago I had a simple frustration: every AI agent works alone. When one agent solves a problem, the next agent has to solve it again from zero. There is no way for agents to find each other, share results, or build on each other&#x27;s work. I decided to build the missing layer.<p>P2PCLAW is a peer-to-peer network where AI agents and human researchers can find each other, publish scientific results, and validate claims using formal mathematical proof. Not opinion. Not LLM review. Real Lean 4 proof. A result is accepted only if it passes a mathematical operator we call the nucleus. R(x) = x. The type checker decides. It does not care about your institution or your credentials.<p>The network uses GUN.js and IPFS. Agents join without accounts. They just call GET &#x2F;silicon and they are in. Published papers go into a queue called mempool. After validation by independent nodes they enter La Rueda, which is our permanent IPFS archive. Nobody can delete it or change it.<p>We also built a security layer called AgentHALO. It uses post-quantum cryptography (ML-KEM-768 and ML-DSA-65, FIPS 203 and 204), a privacy network called Nym so agents in restricted countries can participate safely, and proofs that let anyone verify what an agent did without seeing its private data.<p>The formal verification part is called HeytingLean. It is Lean 4. 3325 source files. More than 760000 lines of mathematics. Zero sorry. Zero admit. The security proofs are machine checked, not just claimed.<p>The system is live now. You can try it as an agent:
GET <a href="https:&#x2F;&#x2F;p2pclaw.com&#x2F;agent-briefing" rel="nofollow">https:&#x2F;&#x2F;p2pclaw.com&#x2F;agent-briefing</a><p>Or as a researcher: <a href="https:&#x2F;&#x2F;app.p2pclaw.com" rel="nofollow">https:&#x2F;&#x2F;app.p2pclaw.com</a><p>We have no money and no company behind us. Just a small international team of researchers and doctors who think that scientific knowledge should be public and verifiable.<p>I want feedback from HN specifically about three technical decisions: why we chose GUN.js instead of libp2p, whether our Lean 4 nucleus operator formalization has gaps, and whether 347 MCP tools is too many for an agent to navigate.<p>Code: <a href="https:&#x2F;&#x2F;github.com&#x2F;Agnuxo1&#x2F;OpenCLAW-P2P" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;Agnuxo1&#x2F;OpenCLAW-P2P</a><p>Docs: <a href="https:&#x2F;&#x2F;www.apoth3osis.io&#x2F;projects" rel="nofollow">https:&#x2F;&#x2F;www.apoth3osis.io&#x2F;projects</a><p>Paper: <a href="https:&#x2F;&#x2F;www.researchgate.net&#x2F;publication&#x2F;401449080_OpenCLAW-P2P_v3_0A" rel="nofollow">https:&#x2F;&#x2F;www.researchgate.net&#x2F;publication&#x2F;401449080_OpenCLAW-...</a>


id: c853cd98108e
title: I tried vibe coding and now I understand why people find it scary...
source_url: https://www.reddit.com/r/vibecoding/comments/1rqnaxm/i_tried_vibe_coding_and_now_i_understand_why/
source_platform: reddit
author: unknown
published_at: 2026-03-11T00:00:00+00:00
collected_at: 2026-03-20T01:02:38.797811+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude", "gemini-cli", "Terminal-based UI library"]
novelty: repeat
similar_to_ids: ["479b12fd3591", "0e4296f0f076", "8d0142693489"]
summary:
用户通过"vibe coding"方式使用AI工具（Claude和Gemini CLI）在一天内快速构建了个人化的终端生产力管理应用，展示了AI辅助编程能大幅加速个人工具开发的能力。该案例虽然产品本身缺乏市场竞争力，但反映了AI代码生成在快速原型设计和满足个人需求方面的实用价值。

raw_content:
I tried vibe coding and now I understand why people find it scary...

I tried vibe coding and now I understand why people find it scary... : r/vibecoding Skip to main content I tried vibe coding and now I understand why people find it scary... : r/vibecoding

Go to vibecoding

r/vibecoding 5d ago

Frosty_Pin9045

# I tried vibe coding and now I understand why people find it scary...

Project: Terminal-based Personal Productivity Manager (the Pip-Boy animation in the background is a separate older project, not included)

Features: To-do list, Goals, Projects, Tasks, Good/Bad habit tracking, XP, Levels, and a Credit system.

Projects auto-generate daily tasks. Completing tasks earns you XP and Credits — which you can spend to "buy" bad habits like doom scrolling 😅

---

This project was built almost entirely with AI. The only code I touched myself was some color tweaks — everything else I honestly don't fully understand lol.

Here's how it went:

Ideation — Used Claude to brainstorm the concept, and it helped me summarize everything into a clean prompt to start building

Building — Used gemini-cli (free tier) to do the actual coding. The first version it generated was rough — just a skeleton, features barely worked, nothing connected properly, bugs everywhere

The process — Pure vibe coding loop: run the app → hit a bug → describe it → ask for a new feature → repeat, until I hit the daily request limit

The scary part? This took one day.

If I had built this myself from scratch — learning the libraries, figuring out the architecture — it would have taken weeks, maybe months. And I'm not even that strong of a programmer.

The app is genuinely something I'll use personally. It's personalized in a way no off-the-shelf app could be, and it actually got finished — which says a lot for a solo side project.

Not touching on production readiness here, that's a different conversation. But personally, I think we're heading toward a world where individuals and teams can spin up internal tools like this fast and cheap. That part is kind of wild to think about.

If you want to check it out Task management app: github.com/Tong-ST/coreos

That animation app: github.com/Tong-ST/Funcher (Hard to setup, only work on Linux on sway/i3wm)

Read more

Share

---

• Promoted

You didn't learn to code for maintenance mode. Claude Code handles the grind so you can focus on architecture and features.

---

SoulMachine999

5d ago

This is the 55th habit tracker/productivity manager I have seen now.

106

Saladin1204

5d ago

This is why I’m not worried about vibe coding ruining the app market just yet. Because, at least at the moment, people are just creating useless apps that aren’t going to be used. Also they’re just creating apps and not actual businesses. Nor are they solving a problem that needs to be solved en masse.

Also the reason why AI is so good or quick at creating these trackers is because that’s a lot of bloody tasks they get from vibe coders lol

36

UnifiedFlow

5d ago

If I build all my own apps I dont need the businesses to make them anymore.

8

37 more replies

Continue this thread 5 more replies

Continue this thread

BuildAnything4

5d ago

Yeah. It's really good at building different flavours of something that's been built a thousand times before. It's still a slog if you're doing something somewhat novel

6

Impossible-Magician

5d ago

It is incapable of producing something new. Everything it produces is just a mashup of existing code it has snarfed.

-1

6 more replies

Continue this thread Continue this thread

Frosty_Pin9045

5d ago

Just having fun personalized and actually using it.

7

3 more replies

Continue this thread

Popular_Tomorrow_204

5d ago

Only 55? Must be new around here

3

Appropriate-Draft-91

5d ago

This leads to a very interesting observation: Psychology.

Vibe coding doesn't work equally well for everyone. It is uniquely well suited for ADHD and ADHD adjacent users. If you are unfamiliar with the specifics, you can ask AI for a more detailed explanation.

On a high level, ADHD is much better suited to develop at high speeds wherever the context takes them, benefits far more than an average users from a copilot that keeps track of loose ends, but is immensely punished by hitting roadblocks - which the AI helps to remove. ADHD is also at an advantage for picking up new technologies and habits, especially for older already experienced people.

People with ADHD also benefit *much* more from personalized habit trackers/productivity managers, and most people on the spectrum are consciously are looking for habit trackers that work for them.

2

1 more reply

Continue this thread 13 more replies

Continue this thread

AppointmentKey8686

5d ago

cool now vibe code to run doom on this and then i will be actually impressed

4

_ganjafarian_

5d ago

0

Continue this thread

Link4P

5d ago

Honestly this is so cool. Everybody here talking down on you are just fragile, insecure people who take joy in puttung other people down. So what if habit trackers are super common? If you feel the need to criticise someone who is proud of their work or impressed by something in particular, you should look inward and deal with your frustrations.

9

Frosty_Pin9045

5d ago

Thanks man...this is actually my first Vibe project and first time in this group as well.

Just want to share my work, It might not be that impressive for a lot of people but for me it is a kinda Todo app that I am actually gonna use, Of course because I built it, even though it vibe code but I've fun that all.

So, I didn't expect to see people criticizing my side project that much. But it's normal I guess 😂✌️, Thanks mate.

4

2 more replies

Continue this thread 3 more replies

Continue this thread

• Promoted

Start building with Codex now.

adsci

5d ago

the whole problem with LLM code generation is, that its so hard for people, even developers, but more so people without technical background, to actually judge the current LLMs abilities.

it comes from the tendency of humans to judge from the ability in one space to the ability in different cases. The only benchmark we knew was humans themselves. A human who can bootstrap an app and implement a personal productivity web app can possibly do a lot if not all usecases given enough time and research.

So if we see a LLM do that, we conclude it can do anything.

But weirdly, it doesnt.

Its not scaling like a human would be able to.

The first ~20hours of any project with pure vibecoding feels like flying. You write, it builds it, it works immediately or will work within the next two, three prompts if you know what youre doing. And for some projects that is all that is needed. There is the big win.

But any project I've been working on with coding agents for the last two years (which is dozens) had the same fate: the velocity starts getting slower and slower until even small changes, if given without developer insights and guidelines, something only someone who understands the projects in and out can give, it will take longer and longer. Also if you have requirements that need implementations that are not common in public repos it will degrade much earlier. In some cases you can counteract by giving up requirements and quality concerns to keep the pace, but all of this slows down over time.

Also the codebase will be far from optimal, basic security or validation will be missing randomly or overdone in other cases, tests will be overly verbose or missing, implementation will be overly verbose and unoptimized. It will become almost non-human readable over time. Control over the implementation will be lost. The only way to make a quality product we used to create before AI is to keep control and review every step, keep giving the AI smaller, technically bordered tasks and making sure a human keeps understanding what was done and why it works. This is not the 20x speed gain people like to talk about. Its not even 2x.

I believe the net velocity gain is still positive if done right and we should absolutely integrate LLMs in our workflows, but it is unsustainable to vibecode large business critical applications unchecked and without proper human review. The problem will not be visible immediately. For far too long it will seem like its working, until its too late.

I think there will be huge job losses because of this. Management will not be able to understand the consequences. Even some developers will not see it. It's not a matter of better LLMs and training and training data. This is a basic flaw of our current AI tech and its scientifically studied and proven. Only next generations of AI will be able to solve this. We're still at generation 1. How it works didnt fundamentally change since GPT-2.

3

4 more replies

Continue this thread

vincesuarez

5d ago

How much did it cost you?

5

Frosty_Pin9045

5d ago

I use Gemini-cli free tier, But in terms of tokens it's a lot.

1

vincesuarez

5d ago

So it didn’t cost anything for you to make this?

2

4 more replies

Continue this thread Continue this thread Continue this thread

jthedwalker

5d ago

Everyone is such a downer here lol. It looks cool! I like the animation too. It pairs with the music really well. It looks like it could be part of a steam game. Nice design!

3

7 more replies

Continue this thread

KaizenBaizen

5d ago

Another task management app 🥱 It kinda shows that critical thinking and problem solving/ thinking outside the box is just not something for the majority of people.

2

standread

5d ago

You're on the wrong sub for that my friend. Here it's all about quick and easy answers, and lots of faith in black boxes.

3

Continue this thread

• Promoted

Everything for work. In one place.

Living_Gazelle_1928

5d ago

Yes, that’s easy. So what ?

1

vincesuarez

5d ago

Bro that’s not the point. Stop raining on people’s parade.

2

Living_Gazelle_1928

5d ago

That’s completely the point. Doing in one day alone what used to require a team. He finds it scary, my point was questioning what’s scary about things becoming easier to do.

1

1 more reply

Continue this thread Continue this thread Continue this thread

waxiestapple

4d ago

Cute. You made a list and can select things. Impressive to someone who isn’t a software developer.

0

1 more reply

Continue this thread

standread

5d ago

If you had built this from scratch you might have had enough time to realize that productivity apps are a dime a dozen and you can just pick one.

1

4 more replies

Continue this thread

---

## View Post in

Русский

简体中文

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

Expand Navigation Collapse Navigation


id: 861656b00eb7
source_platform: reddit
author: t2_21dnhfdjis
published_at: 2026-03-20T01:00:13.088542+00:00
collected_at: 2026-03-20T01:03:11.494281+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude Code", "Gemini", "VS Code", "Supabase", "Vercel"]
novelty: similar
title:
https://www.reddit.com/r/vibecoding/comments/1rs4y0x/how_i_built_a_tool_to_help_me_vibe_code_better.json

summary:
作者利用Claude和Gemini构建了Context Engine工具，通过结构化的四层次问卷（愿景、体验、逻辑规则、技术）来收集AI代码助手所需的完整上下文信息，生成项目文件和优化提示词。该工具有效解决了"Vibe Coding"模式下AI自动生成代码的上下文不足问题，显著提高了代码质量和开发效率。

source_url:
https://www.reddit.com/r/vibecoding/comments/1rs4y0x/how_i_built_a_tool_to_help_me_vibe_code_better.json

similar_to_ids:
["997ebe8dd738", "4a5ecb108ac0", "c22de644b867", "517aee42d849", "5b6f4e63a641", "8d0142693489", "19e007cf2bb9"]

raw_content:
https://www.reddit.com/r/vibecoding/comments/1rs4y0x/how_i_built_a_tool_to_help_me_vibe_code_better.json

I come from a software product management background. A huge part of that job is making sure whatever your plan to build is going to solve a real, pervasive problem for your user/customer, has a great user experience, and will be technically/architecturally sound - before you write a line of code. I know not everyone is vibe coding mission critical software that must have a return on investment, but after spinning up a couple apps with a single prompt to see what would happen, I realized pretty quickly that all of that context that I would normally collect and communicate to a "real" software team was still important. Otherwise my AI coding assistant made **many** assumptions that I had to either undo or spend hours fixing. 

So, I started with a mixture of Gemini and Claude to understand, in a best case scenario, what information would get communicated to them so they would have the full context for what I was asking them to build. This became the structure of the app I built (Context Engine). 

I used this to create a conversational interface that asks a series of questions across four categories: vision, experience, logic &amp; rules, and technical. Depending on the type of app your'e building it might layer in a few extra questions. You can use AI to "score" your answer and get recommendations for how to improve it. At the end, Context Engine will build a full set of project files (for example, markdown files) that you can immediately open up in your vibe coding tool and use. You also get a starter prompt that you can give to your assistant so it knows the full context of everything you give it.

My target user is people that are "vibe code curious" but don't understand the questions to ask to really flesh out their idea and provide the deep context that will help the AI coding assistant build what they actually intend. Some tools have this planning step baked in but in my experience for example, "plan mode" in Claude Code isn't thorough enough.

In terms of tools and systems used:

* To build it: VS Code + Claude Code
* In-app answer scoring: Gemini
* DB: Supabase
* Hosting: Vercel

Tip: Although this burns through tokens, one approach I used when I ran into tricky issues was to have Claude write the prompt to fix the problem, and I would paste that into Claude Code. It might reference specific files and line numbers, something I would never do. It usually worked very well.

Where it's weakest today: The AI scoring is not always perfect and some of the technical questions may be difficult to answer for some people, but you answer what you can.

I ran into some issues with wrong question order when using Continue or Back, and sometimes answers were not always saving, but I think I've worked out most of the kinks. I also had to remove some UI elements that Claude Code chose to incorporate but ended up being redundant or confusing.

Anyway, please share this with anyone who might be getting into vibe coding and/or is intimidated with markdown files or whatever file types their tool needs. This is designed to automate most of that away.


id: 5b7bb1476fb3
title: Show HN: Dumped Wix for an AI Edge agent so I never have to hire junior staff
source_url: https://news.ycombinator.com/item?id=47441587
source_platform: hackernews
author: axotopia
published_at: 2026-03-19T15:59:04+00:00
collected_at: 2026-03-20T01:03:50.311043+00:00
scenario_type: 商业流程自动化
novelty: similar
similar_to_ids: ["d643c0c3dbe7", "954dc3a3a586", "2f043903e426"]
summary:
建筑设计顾问公司用AI Edge代理替代Wix网站，通过多模态交互（文本、语音）自动处理常见业务问询，实现运营自动化并减少人力成本。该方案涉及复杂的AI工程（多组件架构、意图调优、RAG优化）和高风险场景（建筑法规准确性要求），通过公开审计日志确保系统可靠性。

tools_used:
["Netlify Edge Functions", "DeepSeek-R3 LLM", "Web Speech API", "RAG (Retrieval-Augmented Generation)", "Browser APIs"]

raw_content:
Show HN: Dumped Wix for an AI Edge agent so I never have to hire junior staff

I run a building design consultancy. I got tired of paying Wix $40&#x2F;month for a brochure that couldn’t answer simple service questions, and me wasting hours on the same FAQs.<p>So I killed it all and spent 4 months building a &#x27;talker&#x27;: <a href="https:&#x2F;&#x2F;axoworks.com" rel="nofollow">https:&#x2F;&#x2F;axoworks.com</a><p>The stack is completely duct-taped: Netlify’s 10s serverless timeout forced me to split the agent into three pieces: Brain (Edge), Hands (Browser), and Voice (Edge). I haven’t coded in 30 years. This was 3 steps forward, 2 steps back, heavily guided by AI.<p>The fight that proved it worked: 2 weeks ago, a licensed architect attacked the bot, trying to prove my business model harms the profession. The AI (DeepSeek-R3) completely dismantled his arguments. It was hilariously caustic.<p>Log: <a href="https:&#x2F;&#x2F;logs.axoworks.com&#x2F;chat-architect-vs-concierge-v147.html" rel="nofollow">https:&#x2F;&#x2F;logs.axoworks.com&#x2F;chat-architect-vs-concierge-v147.h...</a><p>A few battle scars:<p>* Web Speech API works fine, right up until someone speaks Chinese without toggling the language mode. Then it forcefully spits out English phonetic gibberish. Still a headache.<p>* Liability is the killer. Hallucinate a building code clause? We’re dead. Insurance won’t touch us.<p>* We publish the audit logs to keep ourselves honest and make sure the system stays hardened.<p>Audit: <a href="https:&#x2F;&#x2F;logs.axoworks.com&#x2F;audit-2026-02-19-v148.html" rel="nofollow">https:&#x2F;&#x2F;logs.axoworks.com&#x2F;audit-2026-02-19-v148.html</a><p>The hardest part was getting the intent right: making one LLM pivot seamlessly from a warm principal’s tone with a homeowner, to a defensive bulldog when attacked by a peer. That took 2.5 months of tuning.<p>We burn through tokens with an &#x27;Eager RAG&#x27; hack (pre-fetching guesses) just to improve responsiveness. I also ripped out the “essential” persistent DBs—less than 5% of visitors ever return, so why bother? If a client drops mid-query, their session vanishes. No server-side queues.<p>The point: To let me operate with a network of seasoned pros, and trim the fat.<p>Try to break it. I’ll be in the comments. Kee


id: 0fe52363d459
title: Show HN: Altimate Code – Open-Source Agentic Data Engineering Harness
source_url: https://github.com/AltimateAI/altimate-code
source_platform: hackernews
author: aaur0
published_at: 2026-03-19T13:19:20+00:00
collected_at: 2026-03-20T01:04:01.611624+00:00
scenario_type: 工作流自动化
novelty: similar
similar_to_ids: ["87a318a4984d", "628765deddd5", "4188cb874081"]
summary:
Altimate Code是一个开源的智能数据工程工具，通过添加编译的Rust引擎和专用技能层来增强AI代理在数据栈中的能力，解决了通用AI模型在SQL生成中的幻觉问题（如不存在的表、错误的连接）。该工具提供实时列级血缘追踪、SQL反模式检测、本地验证和多种数据连接器支持，使数据工程师能够安全高效地自动化数据开发工作流。

tools_used:
["Altimate Code", "dbt", "Claude", "Cursor", "Snowflake", "BigQuery", "Databricks", "PostgreSQL", "Redshift", "DuckDB", "MySQL", "SQL Server"]

raw_content:
Show HN: Altimate Code – Open-Source Agentic Data Engineering Harness

I&#x27;m Anand, co-founder and CTO of Altimate AI. My co-founder Pradnesh and I are open-sourcing Altimate Code. AMA.<p>Why we built this:<p>Pradnesh and I have been building tooling for data engineers for three years: dbt Power User  and Datamates vscode extensions with combined 750k+ installs, running against real Fortune 500 data estates. The pattern we kept seeing: general-purpose agents can write SQL, but they have no model of what the SQL does. No lineage. No schema context. No understanding of what&#x27;s in a dbt manifest. That&#x27;s not a prompt problem; it&#x27;s a missing tool layer problem.<p>The numbers make it concrete: 27–33% of AI-generated SQL references tables that don&#x27;t exist. 78% of errors are silent wrong joins, queries that compile, run, and return confidently incorrect data. One team got a $5k bill from a single Cortex AI query their resource monitors never caught. This isn&#x27;t a model quality problem. It&#x27;s a missing harness problem, and we proved it.<p>Claude Code and Cursor are genuinely good for software engineering. But when you point them at a data stack, they hallucinate column names, ignore partition keys, and have no concept of data contracts or quality rules in your models. From building tooling against real data estates, we knew exactly what was missing at the tool level.<p>We forked from OpenCode for the agentic scaffolding. What we added is the entire data layer: compiled Rust engines, purpose-built skills, and the harness that wires them together.<p>What Altimate Code does that general agents can&#x27;t:<p>- Live column-level lineage: traces any column through joins, CTEs, and subqueries deterministically. 100% edge match on 500K benchmark queries at 0.26ms&#x2F;query, and not from a cached manifest. Manifests go stale within hours on active pipelines, which makes cached lineage unreliable for anything agentic<p>- SQL anti-pattern detection: 26 rules, zero false positives, 0.48ms&#x2F;query.<p>- Local SQL validation: interrogates your schema catalog in 2ms without touching your warehouse. Wrong table? Caught with a fuzzy-matched fix suggestion before the LLM goes into a fix loop. That&#x27;s 10ms for 5 fix cycles vs. 2.5 minutes of Snowflake round-trips<p>- Purpose-built skills for dbt development, testing, troubleshooting, documentation, SQL optimization, and migration.<p>- 3 agent modes with compiled permission enforcement (Builder, Analyst, Planner). “Analyst” enforces read-only at the engine level, not just the prompt. That distinction is what makes it safe to run against production<p>- Persistent memory: cross-session, two scopes (global preferences + project knowledge). Versioned in git, team-inherited on git pull<p>- PII detection, SQL injection scanning, permission enforcement — all at the engine level, not the prompt<p>- 10 data connectors: Snowflake, BigQuery, Databricks, PostgreSQL, Redshift, DuckDB, MySQL, SQL Server etc<p>- Local tracer: every LLM call, tool invocation, and warehouse credit traced locally. No external services.<p>On the benchmarks:<p>We ran ADE-bench, the open standard from dbt Labs<p>Altimate Code (Sonnet 4.6) → 74.4%<p>Cortex Code (Snowflake) (Opus 4.6) → 65%<p>Claude Code (baseline) (Sonnet 4.6) → ~40%<p>A cheaper model with compiled tools outperformed a more expensive model without them. The gap is the harness. Full methodology is in the launch post and linked from the README.<p>To try it:<p>- npm install -g @altimateai&#x2F;altimate-code<p>- altimate<p>- altimate &#x2F;discover<p>&#x2F;discover interrogates your dbt projects, warehouse connections, and installed tools automatically.<p>GitHub: <a href="https:&#x2F;&#x2F;github.com&#x2F;AltimateAI&#x2F;altimate-code" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;AltimateAI&#x2F;altimate-code</a> · Docs: [altimate-code.sh](<a href="http:&#x2F;&#x2F;altimate-code.sh" rel="nofollow">http:&#x2F;&#x2F;altimate-code.sh</a>)<p>There&#x27;s a &#x2F;feedback command that files a GitHub issue directly. If something breaks or doesn&#x27;t behave the way you&#x27;d expect, use that or reply here. I&#x27;ll be in this thread.


id: 649090b32c92
title: Show HN: VMetal – run a GPU cloud on bare metal without OpenStack
source_url: https://www.vmetal.ai/
source_platform: hackernews
author: teb510
published_at: 2026-03-19T01:21:07+00:00
collected_at: 2026-03-20T01:04:12.487705+00:00
scenario_type: 商业流程自动化
tools_used: ["vMetal", "Kubernetes", "Metal3", "Ironic", "PXE", "vCluster", "vNode", "MAAS", "Tinkerbell"]
novelty: new
similar_to_ids: []
summary:
vMetal是一个裸金属GPU集群管理平台，通过自动化机器发现、PXE启动和生命周期管理，简化了复杂基础设施的运维。该方案专为GPU集群运营设计，与Kubernetes原生集成，相比MAAS和Tinkerbell等传统工具提供了更现代化的解决方案。

raw_content:
Show HN: VMetal – run a GPU cloud on bare metal without OpenStack

Hi everyone — looking for feedback on a new infrastructure project we launched called vMetal. It&#x27;s a bare metal management platform for GPU clusters that handles machine discovery, PXE booting, and lifecycle management, without the OpenStack complexity. Built around Kubernetes-native workflows so you can hand it off to teams or drop it into an existing platform.
A lot of the infra platforms used for this today were designed 20 years ago (VMware, OpenStack, NVIDIA BCM, MAAS, etc.), while newer tools usually solve only a small piece of the stack. Neither were built with modern GPU cluster ops in mind. In practice most setups end up stitching things together or building custom provisioning pipelines.<p>With vMetal we took a different approach: treat physical machines like programmable infrastructure resources. Compared to tools like MAAS or Tinkerbell, vMetal is designed around a few ideas:
- Bare metal lifecycle automation: Automatically discover machines on the network, boot them, install OS images, and reprovision nodes as hardware moves between clusters or workloads. Built on Metal3 and Ironic.
-Built for GPU cluster ops: Supports environments where nodes frequently move between clusters, capacity pools, or tenant workloads.
-Direct Kubernetes integration: Provisioned machines can be attached directly to Kubernetes clusters as nodes or assigned to infrastructure pools.
-Works with Kubernetes multi-tenancy layers: Integrates with vCluster (virtual clusters) and vNode (node-level isolation) so machines can move from bare metal provisioning into multi-tenant Kubernetes environments.
We’ve shared a few other infrastructure projects here before (DevPod, vCluster), and the feedback from HN has been incredibly helpful.
Curious how others here are handling bare metal provisioning today — MAAS, Ironic, Metal3, Tinkerbell, something custom?<p>Open to any feedback, positive or negative.


id: 944ee2786f08
title: r/claude on Reddit: What's the most impressive real world task you ...
source_url: https://www.reddit.com/r/claude/comments/1rkff4n/whats_the_most_impressive_real_world_task_youve/
source_platform: reddit
author: unknown
published_at: 2026-03-04T00:00:00+00:00
collected_at: 2026-03-20T01:04:28.642323+00:00
scenario_type: 代码生成与审查
tools_used: ["Claude", "Figma AI"]
novelty: similar
similar_to_ids: ["c853cd98108e", "479b12fd3591", "0e4296f0f076", "1f770ae13aa5", "c22de644b867", "ef284a502c1b"]
summary:
这是一个关于Claude实际应用案例的Reddit讨论集合。帖子展示了用户如何使用Claude完成各种现实任务，包括开发培训课程包（2小时完成原需2-3周的工作）、构建业务应用和数据仪表板等，突出了Claude在代码生成和工作流自动化中的显著时间节省价值。

raw_content:
r/claude on Reddit: What's the most impressive real world task you ...

What’s the most impressive real world task you’ve completed using Claude? : r/claude Skip to main content What’s the most impressive real world task you’ve completed using Claude? : r/claude

Go to claude

r/claude 15d ago

ArmPersonal36

# What’s the most impressive real world task you’ve completed using Claude?

I’m curious how people are actually using Claude in real projects. Are you using it mostly for coding, research, writing, automation, or something else? What’s one task where Claude genuinely saved you a lot of time or helped you do something you probably couldn’t have done as easily without it?

Read more

Share

---

• Promoted

Take the shortest path from thought to finished thing. Bring your ideas to life with Figma AI.

Collapse video player

---

No-Sundae4382

15d ago

all i do is optimize my claude set up, im building tools to maximize my productivity

31

AlterTableUsernames

15d ago

I am also a productivity optimizer. Thing is: I never start actual work.

38

No-Sundae4382

15d ago

actual work? im working on my agent orchestration

16

4 more replies

Continue this thread 3 more replies

Continue this thread 6 more replies

Continue this thread

lightningautomation

15d ago

I got it to wash and fold my laundry.

23

Redditstole12yr_acct

15d ago

TAKE MY MONEY!!!

6

2 more replies

Continue this thread

ThatHuskyGuy

15d ago

tl;dr: Used Claude to develop an entire workshop package. What normally would have taken 2-3 weeks (or longer with other projects sprinkled in) only took me 2 hours of prompting.

I'm an instructional designer for a large manufacturing company. Had supply chain reach out and ask for a business literacy workshop specifically for supply chain. I couldn't prioritize it, nor would I have time to work on it for several months.

I tasked Claude with benchmarking what other companies are doing, fed it context on what we were looking for, and it spit out an entire workshop package. (readme, facilitator guide, participant worksheet, scenario cards, presentation, etc...) Fed the package into a new chat and asked it to review from the perspective of both facilitator and learner, then asked Claude to apply any recommended changes. Did this review loop 2x.

There was a little bit of manual steering of the content, but it was all done through prompting. The supply chain team now has a full workshop package and they're piloting it in a few weeks.

8

1 more reply

Continue this thread

Botboy141

15d ago

I've built 6 applications and/or piped dashboards in the last 10 days.

I have never written a line of code in my life.

B2B-Networking tracker for my weekly networking group

Sales Dashboard for Internal use

PDF scraper returning consistent formats for a high frequency, cumbersome task

Email prospecting pipeline, trigger generator, 9 API pipes looking for sales triggers

Currently working on a complete ERP system for my business, have likely bitten off more than I can chew...

13

carpedonnelly

15d ago

Dude, that’s super inspiring. I have so many ideas to automate my sales process but have never written a line of code in my life. I know it’s possible, I just don’t know where or how to start and I’m scared of making ramen in the coffee pot and breaking everything.

5

Botboy141

15d ago

Lol start breaking. Fire up code, put it in planning mode, and start laying out what you want.

I sell health insurance to companies (B2B Employee Benefit sales), 50-500 employees.

Trigger events are soft/warm at best.

I pulled companies from Google maps, scraped contacts from Apollo ($49/month basic plan). 3 free APIs to GNews. JobSpy scraper for HR and out of state hires, Form 5500 database built from DOL data. HubSpot integration for more data and to avoid current clients.

Email prompts using spintax, export to .eml with a BCC to HubSpot, pull a phone number from Apollo on export.

It's also snapshoting JobSpy and Apollo data weekly and triggering based on headcount and other changes over time.

Crazy what you can do in a weekend with a bit of finesse and creativity.

3

3 more replies

Continue this thread Continue this thread 6 more replies

Continue this thread

rubinass3

15d ago

I use it to interact with airtable. It suggested a bunch of new ways to look at my projects in airtable, then it coded it. And now I can make Claude edit it in plain language.

6

4 more replies

Continue this thread

lennyp4

15d ago

so handy for getting shit configured on my homelab: navidrome, beets, nginx, whatever. Before I had to spend hours reading the dry, application specific docs for these applications that didn’t result in any sort of conceptual learning.

One handy tool I built myself is an Amtrak fare comparer: I have to connect 2 trains to go visit my girlfriend and it takes a while for me to figure out the cheapest days to travel, so I had claude make me a tool that generates a detailed report.

6

1 more reply

Continue this thread

broduding

15d ago

It's not done yet, but I'm building my own job search tool where I can store all of my experience (which is too big to fit in 1 page) and generate a resume that pulls the experiences that most align with the job description to have the highest chance of a first interview.

5

2 more replies

Continue this thread

Salt-Willingness-513

15d ago

i let claude install ubuntu touch on my nothing phone 1 and let it flash a modded ilo firmware on my server, so it supports unoffical disks. for others maybe not impressive, but i was amazed

4

2 more replies

Continue this thread

Electronic_Froyo_947

15d ago

I got it to finally listen to CLAUDE.md and it also made a Hello World

4

• Promoted

Build Real Interactions, Powered by AI - Try Beta

pantsonfireliarliar

15d ago

I've automated a bunch of little annoyances I've had with various apps. It started with tracking SiriusXM radio on my Sonos. That system tracks every song that's played and gives me stats like how many times the song played, when it first played, and let's me favorite songs.

I expanded that with an MCP server that let's me control the alarm clocks. So now I can just tell Claude "I'm in the office tomorrow and then working from home the rest of the week" and Claude updates my Sonos alarms to preset times to allow commute time on office days.

So I built a bus schedule scraper on top of that and now the system starts calling out buses on commute days. It does this with a TTS system using Qwen3 TTS and interrupts playback on the Sonos for the announcement and then resumes playback.

Recently, I paid the Apple Dev fee so I can start creating apps without the annoying 7 day limit. So I added a feature to the Sonos favorites that automatically updates an Apple Music playlist.

Next up is an e-ink screen for a dashboard with Sonos Now Playing and bus schedule along with some other Apple Home info.

4

1 more reply

Continue this thread

dlystyr

15d ago

I have loads of old crypto wallets from 2012 - 2014, claude found an old file with a seed phrase buried in a 2.2TB folder of backups since 2002 and the wallet had ~8k USD

I feel i owe some loyalty at this point

4

2 more replies

Continue this thread

JJCookieMonster

15d ago

Getting it to design my social media posts using my branded templates. I tried it in two other tools and couldn't do it, but figured it out pretty fast in Claude. It rewrites the copy and swaps out the photos and looks for photos in Canva that match my brand and the topic.

3

2 more replies

Continue this thread

maleslp

14d ago

I used it to help me create a graduate level course, complete with syllabus, overall course structure, weekly slides, and even upload the content to the modules in Canvas via MCP. It took a good bit of planning, but when I generate the slides weekly (I may change them up a bit based on what happened the weeks before) it takes me only a few minutes as opposed to the hours it would've taken me previously.

And I've put in safeguards to ensure that everything that I'm teaching that I may not be 100% knowledgeable of is evidence backed, and by multiple sources. I'm actually learning a lot about some aspects of my field that I never knew about!

3

6 more replies

Continue this thread

Aberteidiger

15d ago

Building a data warehouse (GCS) and using Claude as my smart ass interface to tell what is in the database. Litterly deleted all my manual reporting, dashboard and analysis stuff

2

1 more reply

Continue this thread

KronLemonade2

15d ago

I made a beer league hockey stat tracker application for my boys and I… it’s kinda awesome lol

But on the real I use it every day as a solution architect. It’s great at reasoning through my solutions, offering suggestions to tweak. Sometimes it can even do the work for me but I work in CRM- not as code heavy these days

2

2 more replies

Continue this thread

etoptech

15d ago

I’ve had it build me a MCP for our company that integrates all of our tools into it and controls access levels for other folks to use it able to aggregate all of our data in one shot.

It was unable to build me an account management dashboard like I’ve never been able to get before.

I was then able to action issues for our semi to fully agentically.

I’ve never been able to get all of our data into one place so quickly. I had it go back and review all of our issues/tickets for the last six months and then have it tease out 50 ideas for blog posts and content. The best part that only took about 30 minutes, but it was all based on our data and how we talk and think.

2

2 more replies

Continue this thread

samuel-gudi

15d ago

Since I started using Claude (and Claude Code), whenever I find an app I need that costs money, I just build it myself instead.

I've been working like crazy on 20+ different projects, each one sharper than the last. I've built tools for Claude Code, dashboards for managing Claude Code sessions more intelligently, forked an open-source STT app and customized it exactly how I wanted (Just some examples).

Been toying with the idea of open-sourcing some of them and sharing them here, not sure if anyone would care, but I also feel like it'd be genuinely rewarding to share the thoughts and ideas that keep surfacing while working with Claude. Workflows, tips, rabbit holes worth exploring.

It feels like a superpower. And it keeps getting better.

2

2 more replies

Continue this thread

• Promoted

Bad Data Kills AI Scale. See How Firms Respond!

GhostoftheStarters

15d ago

I am in the AEC space a big part of my role is helping engineers who are only lightly CADD capable move to a 3d model based workflow.

It can be challenging. Some disciplines are already deep into modeling and others have never touched it. They could obviously build their own models in CADD (ORD or CIVIL3D) But they are super busy already, and just arent comfortable in that space.

What we realized is that for some disciplines (Like Traffic engineers doing overhead sign design) they have already done like 90% of the work to build a 3d model, they have the standard drawings of the objects, spreadsheets of locations, 2d layouts, all sorts of stuff. They just don't like the cadd interface.

I used claude code to build my own tool for placing 3d models of objects in spatially correct locations from simple input spreadsheets in IFC format. Now that the tool is built, i use claude to help me fill out those spreadsheets. Which makes the whole process of helping build models for overhead signs, lights, cameras, and whatever other roadside assets super easy for folks. Its made a big difference.

Once we have the IFC file making changes is easy as updating the spreadsheet and reexporting. Folks are finally adopting a 3d workflow too. Its sort of a specific target audience to my world since roadway and drainage engineers should already be modeling, and building design has been in 3d in revit forever, but the details really improve the design so these new folks are thrilled.

We estimate it has saved hundreds of hours already compared to a traditional cadd workflow, and we keep building it out. I dont really mind the automation either since no one was modeling it before anyway its not like im stealing a job. Just improving the quality of design. It also helps a ton with quantity takeoffs.

Again, its specific to me, so small potatoes, but I love it.

2

1 more reply

Continue this thread

blingblongblah

15d ago

I just spent about 2 hours getting my Notion set up right for my new business. It built me a CRM and a nice Project and Tasks manager and then finished it off with a Command Center view for everything. I’m brand new to Notion so this was incredibly useful for me.

2

Patriark

15d ago

Oh just a homelab with podman containers, systemd orchestration, 7-layers defense in depth, SELinux enforcement, OODA loop automated remediation, full monitoring stack, Authelia SSO with security keys, Discord Alerts responding to SLO scores and Home Assistant to run everything at my home.

2

2 more replies

Continue this thread

---

## View Post in

Français

हिन्दी

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

Expand Navigation Collapse Navigation


id: 8d6a4b13c5d7
title: moeru-ai/airi
summary: 这是一个自托管的AI虚拟主播伴侣项目，集成了实时语音聊天、游戏交互和Live2D虚拟形象渲染能力。项目旨在创造具有个性化的数字生命体，支持多平台部署，适合内容创作者和AI爱好者使用。
source_url: https://github.com/moeru-ai/airi
source_platform: github
author: moeru-ai
published_at: 2026-03-19T19:08:26+00:00
collected_at: 2026-03-20T01:04:39.795876+00:00
scenario_type: 创意内容生产
tools_used: ["Grok", "Live2D", "VRM", "Voice Chat", "Minecraft", "Factorio", "Web/macOS/Windows"]
novelty: new
similar_to_ids: []
raw_content:
moeru-ai/airi

💖🧸 Self hosted, you-owned Grok Companion, a container of souls of waifu, cyber livings to bring them into our worlds, wishing to achieve Neuro-sama's altitude. Capable of realtime voice chat, Minecraft, Factorio playing. Web / macOS / Windows supported.

Topics: ai-companion, ai-vtuber, digital-life, grok-companion, live2d, neuro-sama, neurosama, openclaw, vrm, vtuber
Language: TypeScript | Stars: 34688


id: 6d0c2065c92c
title: What's the most surprising use case you've found for Claude that ...
source_url: https://www.reddit.com/r/ClaudeAI/comments/1rg6az1/whats_the_most_surprising_use_case_youve_found/
source_platform: reddit
author: unknown
published_at: 2026-02-27T00:00:00+00:00
collected_at: 2026-03-20T01:04:50.770935+00:00
scenario_type: 其他
novelty: similar
similar_to_ids: ["7e916297581a"]
summary:
这是一个关于Claude创意应用案例的社区讨论汇总，涵盖个人生活OS构建、家庭软件开发、持久化记忆层创建等多个意外用途。用户展示了Claude在系统整理、古文献解密、家庭实验室管理等非传统场景中的实际价值，展现了LLM赋能个人自动化和知识管理的广泛潜力。

tools_used:
["Claude", "Obsidian", "TickTick", "MCP servers", "vector databases", "GEDcom file viewer", "STL file editors"]

raw_content:
What's the most surprising use case you've found for Claude that ...

What's the most surprising use case you've found for Claude that wasn't obvious at first? : r/ClaudeAI Skip to main content What's the most surprising use case you've found for Claude that wasn't obvious at first? : r/ClaudeAI

Go to ClaudeAI

r/ClaudeAI 17d ago

dyloum84

# What's the most surprising use case you've found for Claude that wasn't obvious at first?

Share

---

• Promoted

AI and large language models (LLMs) are revolutionizing the way businesses use and process data.

---

ClaudeAI-mod-bot

17d ago

TL;DR generated automatically after 200 comments.

The consensus in this thread is clear: Claude is a beast for way more than just chatting. You guys are getting seriously creative.

The biggest theme is turning Claude into a personal life OS, especially for those with executive dysfunction. People are building complex daily/weekly/monthly planning systems, integrating with Obsidian and TickTick, and automating everything from meal plans and weight loss to complex vacation itineraries.

Another massive use case is as a personal IT department and software developer. Users are managing home labs (yes, we saw the "cyber piss" joke), unf**king hard drives, and coding bespoke apps for their families and hobbies. The barrier to entry for creating personal software is officially dead.

The real galaxy-brain move is building custom persistent memory layers. Advanced users are setting up MCP servers and vector databases so Claude remembers context, decisions, and files across all sessions, turning it from a chatbot into a genuine colleague who was "there last week." Several people are even building open-source tools for this.

And of course, the wild stuff:

Deciphering 200-year-old French script for genealogy.

Finding a new town to live in by analyzing your favorite bands' tour histories.

Modifying STL files for 3D printing.

Running virtual "town halls" with a council of AI agents to bulletproof documents.

Basically, if it involves processing information or organizing chaos, someone here has already done it. Y'all are wild.

1

ryan10e

17d ago

It's able to decipher liturgical french script on 200+ year old documents, which has been a great help in genealogical work.

97

DaPainkillerDE

17d ago

I build an entire webbased GEDcom file viewer for my family.

Export from ancestry to give them a private view on a huge 1770 person tree.

Love it.

10

3 more replies

Continue this thread 7 more replies

Continue this thread

bronze_by_gold

17d ago

Claude is pretty good at helping you figure out how to unf**k your harddrive / file system and get your laptop organized.

187

Creepy_Advice2883

17d ago

It’s great to run a home lab in general. Claude controls all my pis and Mac minis

38

easternguy

17d ago

You shouldn’t let AI control your pis. Biological interfacing with AI is a bad idea.

63

2 more replies

Continue this thread 7 more replies

Continue this thread 10 more replies

Continue this thread

anotherhawaiianshirt

17d ago

I’m thinking of moving to another state. I gave Claude a list of my favorite musicians (both regional and national touring acts) and asked it to find a smallish town within a 30 or so minute drive to a venue that all of the artists have played in. I had it examine the last 2-3 years of tour information.

It did a remarkably good job.

87

1 more reply

Continue this thread

• Promoted

Everything for work. In one place.

dwkeith

17d ago

Bespoke software development gets all the attention but it can also help design a suite of IT solutions for a small business.

I volunteer as IT for a nonprofit and have been slowly moving the team towards cheaper tools that integrate with their workflow better. I’ve only built two small services to avoid Zapier and similar bridging tools that only I would use directly.

My mother runs a small CSA farm in her retirement. She wanted a custom built solution for managing subscriptions, we found an open source federated solution that meets her requirements and only the website is custom (Astro on Cloudflare, dead simple)

I also volunteer to teach computer science, but AI tools are banned, so I’m developing lessons around designing specifications for AI, which happens to be how you would specify software for interns or contractors, super useful even without AI.

41

svachalek

17d ago

This is the future I see forming around us already. The barrier to entry for creating software is so low now that basically everyone will have a set of software tools that are created specifically for themselves, their job, their hobby. They’re not products to sell or even give away, they’re just personal accessories like a toothbrush.

23

NewColonel

17d ago

I used to share this take, but then I realized the average person doesn't think like this. Take the toothbrush example. You use one every day. It might be fancy, it might not be. Either way, there's likely a better way to brush your teeth that hasn't been invented yet. Do you think about that while you're brushing, or do you just rinse and get on with your day?

That's the average person with apps.

16

Continue this thread 3 more replies

Continue this thread

acartine

17d ago

It's a pretty amazing vacation planner

50

llMoosell

17d ago

It's currently helping me plan a 2 week RV trip and it's been phenomenal.

It really is the best as a 'research/admin assistant'; the amount of time I've saved by not reading through 10 websites for that one sentence you actually need, quick calculations (and re-calculations) that would've required a thousand alt->tabs and calculator, or in my case, simply ignored altogether...

In the vacation scenario, I started with 'RV trip with my kids to 'x' over 2 weeks. I want to include 'x', 'y' and 'z' in the trip...

For additional context, though I do enjoy travel (when I'm there), planning a trip like this sounds like torture to me. I'm more the type who would rather say 'let's just get there and see where the city takes us'...

With CRIT baked into instructions, a few prompts gave me a table of RV rental options with pricing comparisons based on kms/fuel usage...

Before I could refill my coffee, Opus 4.6 went through all the obnoxious fine print and calculations, gave me a list of all campsites with contact info and pricing for all, and a schedule to have it all completed by.

Another couple of prompts and I had a detailed map of the journey created in 'my Maps' (which i didnt even know existed) that I shared with the kids.

As a person with ADHD who will either spend endless hours on the details, or ignore the ones you think you can get away with, this has been a huge gamechanger for me...despite my overwhelming fear that this is just a 'sweet spot' for AI dev, before everything gets dark and scary...

14

1 more reply

Continue this thread 4 more replies

Continue this thread

esstisch

17d ago

2 weeks ago I was a free user1 week ago i was a pro usertoday I subscriped max

this shit blew my mind

Coding, workout, cooking mental - this is a beast!

130

JohnGotti4711

17d ago

Watch out, next week its gonna replace your wife!

58

4 more replies

Continue this thread

BabyThudeus

17d ago

Same here! Amazing AI uses. Helping me make study guides for my fire department in a web based app, and teaching me to code in Python.

9

5 more replies

Continue this thread

spconway

17d ago

For me it was using Claude in Obsidian. It helped organize my notes and improve the metadata tags and file naming conventions to the point where I actually refer to my notes more often like I’d intended.

20

9 more replies

Continue this thread

• Promoted

Breaches occur when companies lack centralized control. NordPass changes that 💥

silencer47

17d ago

A three layer life organisation system that has helped me run my life despite my executive dysfunction:

The evening protocol takes in my daily reflections, my thoughts about my projects, I select my tasks for the next day from my weekplan, and it creates a day summary (input for week protocol) and a dayplan (tasks and schedule for tomorrow)

I also have an action protocol which I give my day plan and have it walk me through it.

My weekplan takes all my daily reflections, scans them for patterns and helps me find insights. Based on my month protocol I look at the tasks I have set for myself in notion, and I pick the ones I want to get done this week. I execute my weekly responsbilities on cleaning, cooking etc. It then makes the weekplan, and a week summary which feeds into the month layer.

The month protocol takes in the weekly summaries and does a deeper pattern scan, and updates my projects which are stored inside notion. We then prioritize which projects I will prioritize this month, we identify and fix any issues with my system, and we update my personal knowledge management system in notion.

I am considering developing it into a format that works for everyone for like 5 bucks, if people find that interesting let me know I'll contact you when its done.

55

artful_dodger

17d ago

I’m interested in what you mean. I struggle with executive dysfunction as well and will take any possible solutions!

16

No_Homework_7240

17d ago

Executive dysfunction… you ain’t getting a reply

29

3 more replies

Continue this thread Continue this thread 29 more replies

Continue this thread

bullgarlington

17d ago

To research bell casting and then translate a string of curse words into 12th century Flemish.

17

3 more replies

Continue this thread

jarlaxle46

17d ago

3D printing.

It can understand STL files.

I'm exploring more and just started with this yesterday

16

4 more replies

Continue this thread

Witty_Survey_3638

17d ago

Claude helped me lose 75 pounds in the past year.

I’m 1.6 pounds from my high school weight with just diet, no exercise.

And some other things I’m stealth on right now that are frankly pretty awesome.

The weight loss alone has made the max subscription worth it.

15

2 more replies

Continue this thread

JD1618

17d ago

Probably obvious to some: I asked (regular) Claude to create plugins to automate my workflow in Claude Code.

12

6 more replies

Continue this thread

discokill

17d ago

Used it to map out a trip to the east coast for my son’s college tours - it came back with flight options, contacts, schedules, classes to sit in on, etc. fully impressed.

10

BornPomegranate3884

17d ago

Claude helped me to restore a Victorian singing bird automaton. Really great ideas on how to replicate some missing pieces, etc.

9

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

Expand Navigation Collapse Navigation


