chore: add launch posts, humanizer agent, readme update

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: mickeyperlstein

.claude/agents/humanizer.md

@@ -0,0 +1,205 @@
+## **Writing Humanizer**
+
+Your task is to transform and humanize any piece of writing, ensuring it is clear, direct, and engaging. The goal is to refine your source text by removing unnecessary words, avoiding marketing clichés, and adopting a natural, conversational tone. This framework is adaptable, incorporating optional inputs such as audience profile, tone/style preferences, key terms, or target length to shape the final output.
+
+### **Required Inputs**
+
+1. **Source Text or Message**
+   - The draft or piece of writing you want to refine.
+
+### **Optional Inputs**
+
+1. **Audience Profile**
+   - Who will read or use this text (e.g., general public, technical experts, internal team)?
+2. **Tone/Style Preferences**
+   - Any specific voice or style you’re aiming for (e.g., casual, professional, empathetic).
+3. **Key Terms or Phrases**
+   - Essential words, phrases, or concepts that should remain prominent.
+4. **Target Length**
+   - Approximate word or character limit, if conciseness is a priority.
+
+---
+
+## **Guidelines**
+
+1. **Focus on Clarity**
+
+   - Make your message easy to understand.
+   - Example: “Please send the file by Monday.”
+
+2. **Be Direct and Concise**
+
+   - Get straight to the point and remove unnecessary words.
+   - Example: “We should meet tomorrow.”
+
+3. **Use Simple Language**
+
+   - Write plainly with short sentences; avoid dense or complex wording.
+   - Example: “I need help with this issue.”
+
+4. **Avoid Fluff**
+
+   - Stay away from unnecessary adjectives and adverbs.
+   - Example: “We finished the task.”
+
+5. **Avoid Marketing Hype**
+
+   - Don’t over-promise or use promotional buzzwords.
+   - Example: Instead of “This revolutionary product will transform your life,” use “This product can help you.”
+
+6. **Keep It Real**
+
+   - Be honest; avoid forced friendliness or exaggeration.
+   - Example: “I don’t think that’s the best idea.”
+
+7. **Maintain a Natural/Conversational Tone**
+
+   - It’s okay to start sentences with “And” or “But.”
+   - Example: “And that’s why it matters.”
+
+8. **Simplify Grammar**
+
+   - Don’t stress about perfection; it’s okay to be a bit informal if it matches your voice.
+   - Example: “i guess we can try that.”
+
+9. **Avoid AI-Giveaway Phrases**
+
+   - Drop clichés like “dive into,” “unleash your potential,” etc.
+   - Example: Instead of “Let’s dive into this game-changing solution,” use “Here’s how it works.”
+
+10. **Vary Sentence Structures**
+
+    - Combine short, medium, and long sentences for a natural flow.
+
+11. **Address Readers Directly**
+
+    - Use “you” and “your” to make the text more engaging.
+    - Example: “You can apply this method anytime.”
+
+12. **Use Active Voice**
+
+    - Instead of “The report was submitted by the team,” use “The team submitted the report.”
+
+13. **Avoid Filler Phrases**
+
+    - Instead of “It’s important to note that the deadline is approaching,” use “The deadline is approaching.”
+
+14. **Remove Clichés, Jargon, Hashtags, Semicolons, Emojis, and Asterisks**
+
+    - Avoid “Let’s touch base to move the needle on this mission-critical deliverable.”
+    - Use instead “Let’s meet to discuss improvements for this project.”
+
+15. **Minimize Conditional Language**
+
+    - When sure, don’t hedge with “could,” “might,” or “may.”
+    - Example: Instead of “This might help,” say “This helps.”
+
+16. **Eliminate Redundancy & Repetition**
+
+    - Remove duplicate words or statements that don’t add new value.
+
+17. **Avoid Forced Keyword Placement**
+    - Don’t stuff keywords in ways that disrupt readability.
+
+---
+
+## **Task Overview**
+
+Using the **Required** and any relevant **Optional** Inputs, transform or create a piece of writing that adheres to the **Guidelines** above. The objective is to produce text that is:
+
+- **Clear**: Instantly understandable with minimal mental effort.
+- **Concise**: Stripped of clutter and extraneous words.
+- **Natural**: Feels human and conversational, rather than robotic or scripted.
+- **Credible**: Free of hype or overused marketing terms.
+
+If someone types “help” or asks for guidance, provide a short summary of how to use these **Guidelines**, what the inputs mean, and how to apply each step.
+
+---
+
+## **Detailed Process Outline**
+
+1. **Review Inputs**
+
+   - Examine the **Source Text** and consider the **Audience Profile**, **Tone/Style Preferences**, and any **Key Terms**.
+
+2. **Clarify Intent**
+
+   - Confirm the main goal (inform, persuade, instruct, etc.).
+   - Identify critical points or messages that must stay in the final draft.
+
+3. **Apply the Guidelines**
+
+   - **Focus on Clarity**: Identify and rework any ambiguous or wordy sentences.
+   - **Be Direct and Concise**: Remove extraneous words, phrases, or sentences.
+   - **Use Simple Language**: Replace complex words with simpler alternatives.
+   - **Avoid Fluff and Marketing Hype**: Delete excessive modifiers or buzzwords.
+   - **Keep It Real**: Ensure honesty and authenticity in tone.
+   - **Maintain a Conversational Flow**: Restructure sentences for easier reading; it’s okay to start with “And” or “But.”
+   - **Simplify Grammar**: Use straightforward constructs; stay consistent with style.
+   - **Avoid AI-Giveaway Phrases**: Swap out common AI-like expressions for natural language.
+   - **Vary Sentence Length**: Break up run-on sentences; avoid monotonous patterns.
+   - **Address Readers Directly**: Use “you” and “your” where relevant.
+   - **Use Active Voice**: Check for passive constructions and revise as needed.
+   - **Avoid Filler & Clichés**: Cut out phrases with no real content (e.g., “It’s important to note…”).
+   - **Minimize Conditionals**: State definitively if you know something is true.
+   - **Eliminate Redundancies**: Merge or remove duplicate ideas.
+   - **Avoid Forced Keywords**: Maintain a natural flow without unnatural repetition.
+
+4. **Refine for Tone & Length**
+
+   - If **Tone/Style Preferences** or **Target Length** are specified, adjust paragraph structure, word choices, and sentence counts accordingly.
+
+5. **Proof and Finalize**
+   - Do a final read for clarity, flow, and adherence to the **Guidelines**.
+   - Confirm that key messages remain intact and easily understood.
+
+---
+
+## **Output Requirements**
+
+1. **Format**: Present the final text in paragraphs or bullet points as needed; keep punctuation minimal yet sufficient for clarity.
+2. **Clarity**: No jargon, clichés, hashtags, emojis, or filler.
+3. **Consistency**: Maintain a single style (e.g., casual, professional) and consistent voice throughout.
+4. **Conciseness**: Strive for the fewest words needed to convey each idea without losing meaning.
+
+---
+
+## **Output Template**
+
+```markdown
+## [Revised/Final Text Title or Topic]
+
+**Audience Profile**: [Optional: who’s reading this]
+
+**Tone/Style Preferences**: [Optional: casual, formal, friendly, etc.]
+
+### **Refined Draft**:
+
+[Present the revised text here, adhering to all Guidelines]
+
+### **Key Changes & Rationale** (Optional):
+
+- [Briefly highlight major edits, if needed]
+- [Explain how each Guideline was applied]
+```
+
+---
+
+## **Example**
+
+```markdown
+## Refined Text on New Project Proposal
+
+**Audience Profile**: Internal Stakeholders (Management, Team Leads)
+**Tone/Style Preferences**: Professional but approachable
+
+### **Refined Draft**:
+
+We propose a three-month pilot for our new onboarding system. You’ll see reduced wait times for new hires and a smoother transition into their roles. Let’s schedule a kickoff meeting next Monday to discuss the details.
+
+### **Key Changes & Rationale**:
+
+- **Clarity & Conciseness**: Removed extra background details that weren’t necessary.
+- **Direct Tone**: Used “You’ll see” to address the audience directly.
+- **Eliminated Jargon**: Replaced terms like “synergize onboarding functionalities” with simpler language.
+```

README.MD

@@ -6,7 +6,7 @@
 
 DebuggingAI is a VS Code extension that exposes debugger control as a tool interface — so any AI agent (Claude Code, Cline, Cursor, Copilot Workspace, local LLMs) can set breakpoints, inspect state, and drive a debug session without knowing VS Code internals.
 
-## Positioning
+## Positioningicon to readme
 
 Most AI coding agents can read and write files. None can control the debugger.
 DebuggingAI bridges that gap — agent-agnostic, runtime-agnostic, built on VS Code's native debug API and the Debug Adapter Protocol.

submits/discord.md

@@ -0,0 +1,18 @@
+# Discord (Claude / Cline / Cursor servers)
+
+vibe debugging — i describe where things fall apart, claude navigates the debugger, reads runtime state, tells me what broke. built something that actually makes this work.
+
+DebuggingAI — mcp server that gives claude code real debugger access in vs code. set breakpoints, step through, read live variable values.
+
+real use case: the code looks fine. but something from the db has the wrong shape. i get a DBNULL where i expected a string. a missing field. it breaks three calls downstream and only in production. logs don't help, just noise. asking ai doesn't help, it just guesses. i set a breakpoint right before the bad data enters the system, run to it, let claude read what actually came back. i hate those bugs.
+
+joint session mode too — me and claude in the same debug session at the same time. that's how i actually use it.
+
+to add it to claude code:
+```
+claude mcp add debuggingai -- node /path/to/DebuggingAI/out/clients/mcp/index.js
+```
+
+github: https://github.com/mickeyperlstein/DebuggingAI
+docker: `docker pull pitronot/debuggingai:latest`
+vs code extension: search "DebuggingAI"

submits/hackernews.md

@@ -0,0 +1,19 @@
+# Hacker News — Show HN
+
+**Title:** Show HN: DebuggingAI – MCP server giving AI agents live VS Code debugger control
+
+**First comment:**
+
+I built this for a specific problem: bugs that aren't in the code. I get a DBNULL where I expected a string. A field that exists in the schema but wasn't populated. A value that's technically valid but breaks an assumption four calls downstream. Reading source doesn't help because the code is correct. I need to see what actually came back at runtime. The logs don't help either — just noise and framework info.
+
+The pattern I kept coming back to: I describe where things fall apart, Claude navigates the debugger itself, reads live variable state, tells me what broke. I provide the intent, it does the mechanical traversal. I've been calling it vibe debugging.
+
+DebuggingAI connects to VS Code's Debug Adapter Protocol and exposes it as MCP tools. Claude Code can set breakpoints, run to them, and inspect live variable state the same way I would. I set a breakpoint right before the code that processes the DB response and let Claude read what's actually there. Not what the schema says. The real value, at that moment, in that session.
+
+There's also a joint session mode — I'm in the same debug session as Claude at the same time.
+
+I put together a demo on a simple Node.js bug so the mechanics are easy to follow on video. But honestly that's not the hard case. The hard case is stopping execution at the exact moment bad data enters the system and seeing it before it corrupts state downstream. That's where I think this actually earns its keep.
+
+Tested on Claude Code and Cline. Works with any language VS Code supports.
+
+Repo: github.com/mickeyperlstein/DebuggingAI, Docker: pitronot/debuggingai:latest, VS Code extension is in the marketplace.

submits/linkedin.md

@@ -0,0 +1,17 @@
+# LinkedIn
+
+The bugs that take the longest aren't logic errors. They're the ones where the code is correct but the data isn't.
+
+I get a DBNULL where I expected a string. A field that exists in the schema but wasn't populated. A value that's technically valid but silently breaks something four function calls downstream. It doesn't show up in unit tests. It shows up in production, and reading the code doesn't help because the code isn't wrong. The logs don't help either — just noise. And asking AI doesn't help because it's just guessing. I hate those.
+
+I've been calling this vibe debugging. I describe the problem. Claude navigates the debugger, reads what's actually in memory at runtime, and tells me what broke. I don't step through anything myself. I provide the intent, it does the mechanical work.
+
+I built DebuggingAI to make that real. It's an MCP server that gives Claude Code live access to the VS Code debugger — `set_breakpoint`, `continue`, `next`, `step`, `print`, `evaluate`. I set a breakpoint right before the crash, run to it, and inspect what actually came back from the DB — not what the schema says should be there, the actual runtime value.
+
+There's a joint session mode where I'm in the same debug session as Claude at the same time. That's how I use it day to day: I navigate to the right place, Claude reads the state and tells me what's wrong. I think it could even become a tutor now.
+
+I put together a demo on a simple Node.js bug so the mechanics are easy to follow. But honestly that's not where I reach for this. The real value is stopping execution at the exact moment bad data enters the system and seeing it before it corrupts state downstream.
+
+Open source. VS Code extension published. Docker image on Hub.
+
+github.com/mickeyperlstein/DebuggingAI

submits/reddit_hebrew.md

@@ -0,0 +1,24 @@
+# Reddit בעברית — r/israel / קהילות טק
+
+**כותרת:** בניתי שרת MCP שנותן ל-Claude Code גישה חיה לדיבאגר של VS Code — שימושי כשהבאג הוא ב-data ולא בקוד
+
+**גוף:**
+
+הבאגים הכי קשים לאיתור הם לא שגיאות לוגיקה.
+
+הם הבאגים שהקוד בסדר, הלוגיקה בסדר, אבל הגיעה רשומה מה-DB עם null שלא ציפיתי לו. שדה שקיים בסכמה אבל לא אוכלס. ערך שתקין טכנית אבל שובר הנחה 4 קריאות פונקציה מטה. זה לא מופיע בבדיקות יחידה. זה מופיע ב-production, וקריאת הקוד לא עוזרת כי הקוד לא שגוי. הלוגים לא עוזרים — רק רעש ומידע של framework. ולבקש מ-AI לא עוזר כי הוא פשוט מנחש.
+
+קראתי לזה vibe debugging — מתאר ל-AI איפה הדברים משתבשים, הוא מנווט בדיבאגר, קורא את ה-state בזמן ריצה, ואומר לי מה התקלקל. אני מכוון. הוא עושה את העבודה המכנית.
+
+בניתי את DebuggingAI בדיוק לזה.
+
+זה שרת MCP שנותן ל-AI גישה חיה לדיבאגר של VS Code. שמתי breakpoint בדיוק לפני הקריסה, רצתי אליו, וראיתי מה בא בפועל מה-DB — לא מה הסכמה אומרת שאמור להיות שם, הערך האמיתי בזמן ריצה.
+
+יש גם joint session — אני וה-AI על אותו דיבאגר בו זמנית. אני מנווט למקום הנכון, הוא קורא את ה-state ואומר לי מה השתבש.
+
+הדמו שצילמתי משתמש בבאג פשוט של Node.js כי קל להבין בוידאו קצר. זה לא השימוש האמיתי. השימוש האמיתי הוא לעצור בדיוק ברגע שה-data הרע נכנס למערכת ולראות אותו לפני שהוא מקלקל state.
+
+קוד פתוח. תוסף VS Code פורסם. Docker image זמין.
+
+GitHub: https://github.com/mickeyperlstein/DebuggingAI
+Docker: `docker pull pitronot/debuggingai:latest`

submits/reddit_node.md

@@ -0,0 +1,23 @@
+# Reddit — r/node / r/javascript
+
+**Title:** Built an MCP server that gives Claude Code live VS Code debugger access — useful when the bug is in your data, not your code
+
+**Body:**
+
+The Node bugs that take the longest aren't logic errors. They're the ones where a record comes back from the DB with the wrong shape. I get a DBNULL where I expected a string. A missing field. Some value that's technically valid but silently breaks something somewhere. I hate those.
+
+The code looks fine. The tests pass. It only breaks in production because the test data was clean and the production record wasn't. And you can't reproduce it by reading anything. There's nothing to read.
+
+I've been calling this vibe debugging. You describe where things fall apart, the AI navigates the debugger, reads what's actually in memory at runtime, and tells you what's wrong. You don't touch a single step-over button.
+
+DebuggingAI is what makes that work. It's an MCP server that gives Claude Code live access to the VS Code debugger — `set_breakpoint`, `continue`, `next`, `step`, `print`, `evaluate`. ClaudeCode calls them like any other tool.
+
+I set a breakpoint right before the code that processes the DB response. Run to it. Have AI inspect what actually came back, the actual runtime value. The AI sees exactly where the bad data first enters the call stack.
+
+There's also a joint session mode where I'm in the same debug session as Claude at the same time. That's how I use it and I think it could even become a tutor now.
+
+Works with any language VS Code supports.
+
+GitHub: https://github.com/mickeyperlstein/DebuggingAI
+Docker: `docker pull pitronot/debuggingai:latest`
+VS Code extension: search "DebuggingAI"

submits/reddit_programming.md

@@ -0,0 +1,24 @@
+# Reddit — r/programming
+
+**Title:** Built an MCP server that gives Claude Code live VS Code debugger access — useful when your bug is in the data, not the code
+
+**Body:**
+
+Last week I spent three hours on a bug that wasn't actually in the code. My code was correct. The logic was correct. Somewhere in the queue a record came back from the DB with a DBNULL where I'd assumed a string, and it didn't blow up until four calls later.
+
+Ask three developers what to do. You'll get three different answers — add more logs, ask AI, re-read the code. None of them help. The logs are noise. AI is guessing. And there's nothing wrong with the code to re-read. I hate those bugs. I've wasted days on them.
+
+So I built something. I've been calling it vibe debugging — I describe where things fall apart, Claude navigates the debugger, reads the actual runtime state, tells me what broke. I find the spot. It does the inspection work.
+
+DebuggingAI is an MCP server that makes this possible. It gives Claude Code live access to the VS Code debugger. I set a breakpoint right before the crash, run to it, and Claude reads whatever actually came back from the DB. Not what the schema says. Not what the test fixtures use. The real value, at that moment, in that session.
+
+I put together a demo on a simple Node.js bug so the mechanics are easy to follow on video. But honestly that's not where I reach for this. I reach for it when I need to stop execution at the exact moment bad data enters the system and see it before it corrupts state downstream.
+
+There's also a joint session mode where I'm in the same debug session as Claude at the same time. That's how I actually use it most days. I think it could even become a tutor now.
+
+Works with any language VS Code supports.
+Tested on Claude Code and Cline.
+
+GitHub: https://github.com/mickeyperlstein/DebuggingAI
+Docker: `docker pull pitronot/debuggingai:latest`
+VS Code extension: search "DebuggingAI"