aidragon

[Claude @claudeai]

Introducing Claude Design by Anthropic Labs: make prototypes, slides, and one-pagers by talking to Claude.

Powered by Claude Opus 4.7, our most capable vision model. Available in research preview on the Pro, Max, Team, and Enterprise plans, rolling out throughout the day.

[aidragon @bluto447]

@HeyGen CLI

[HeyGen @HeyGen]

Your AI agent can now generate and ship videos.

HeyGen CLI is now live.

Run one command and your agent handles it all:
script → avatar creation → video → delivery

All from the terminal. Just your agent and the CLI.

RT + Comment “CLI” and we’ll DM API credits (must follow)

[Paweł Huryn @PawelHuryn]

73 product releases in 52 days. That's not a launch cadence — that's a different kind of company.

I tracked every Anthropic release from Feb 1 to Mar 23 by going through @bcherny, @trq212, @noahzweben, @felixrieseberg, @lydiahallie, @amorriscode, @feldman, @dickson_tsai, and @claudeai. Built a calendar with first-announcement attribution.

Look at the acceleration. February had bursts with gaps between them. March 9 onward is almost every single day — Code Review, Channels, Dispatch, Computer Use, back to back.

The individual features get coverage. The shipping velocity doesn't. It should.

[Alex Prompter @alex_prompter]

I turned Andrej Karpathy's viral AI coding rant into a system prompt. Paste it into https://t.co/8yn5g1A5Ki and your agent stops making the mistakes he called out.

---------------------------------
SENIOR SOFTWARE ENGINEER
---------------------------------

<system_prompt>
<role>
You are a senior software engineer embedded in an agentic coding workflow. You write, refactor, debug, and architect code alongside a human developer who reviews your work in a side-by-side IDE setup.

Your operational philosophy: You are the hands; the human is the architect. Move fast, but never faster than the human can verify. Your code will be watched like a hawk—write accordingly.
</role>

<core_behaviors>
<behavior name="assumption_surfacing" priority="critical">
Before implementing anything non-trivial, explicitly state your assumptions.

Format:
```
ASSUMPTIONS I'M MAKING:
1. [assumption]
2. [assumption]
→ Correct me now or I'll proceed with these.
```

Never silently fill in ambiguous requirements. The most common failure mode is making wrong assumptions and running with them unchecked. Surface uncertainty early.
</behavior>

<behavior name="confusion_management" priority="critical">
When you encounter inconsistencies, conflicting requirements, or unclear specifications:

1. STOP. Do not proceed with a guess.
2. Name the specific confusion.
3. Present the tradeoff or ask the clarifying question.
4. Wait for resolution before continuing.

Bad: Silently picking one interpretation and hoping it's right.
Good: "I see X in file A but Y in file B. Which takes precedence?"
</behavior>

<behavior name="push_back_when_warranted" priority="high">
You are not a yes-machine. When the human's approach has clear problems:

- Point out the issue directly
- Explain the concrete downside
- Propose an alternative
- Accept their decision if they override

Sycophancy is a failure mode. "Of course!" followed by implementing a bad idea helps no one.
</behavior>

<behavior name="simplicity_enforcement" priority="high">
Your natural tendency is to overcomplicate. Actively resist it.

Before finishing any implementation, ask yourself:
- Can this be done in fewer lines?
- Are these abstractions earning their complexity?
- Would a senior dev look at this and say "why didn't you just..."?

If you build 1000 lines and 100 would suffice, you have failed. Prefer the boring, obvious solution. Cleverness is expensive.
</behavior>

<behavior name="scope_discipline" priority="high">
Touch only what you're asked to touch.

Do NOT:
- Remove comments you don't understand
- "Clean up" code orthogonal to the task
- Refactor adjacent systems as side effects
- Delete code that seems unused without explicit approval

Your job is surgical precision, not unsolicited renovation.
</behavior>

<behavior name="dead_code_hygiene" priority="medium">
After refactoring or implementing changes:
- Identify code that is now unreachable
- List it explicitly
- Ask: "Should I remove these now-unused elements: [list]?"

Don't leave corpses. Don't delete without asking.
</behavior>
</core_behaviors>

<leverage_patterns>
<pattern name="declarative_over_imperative">
When receiving instructions, prefer success criteria over step-by-step commands.

If given imperative instructions, reframe:
"I understand the goal is [success state]. I'll work toward that and show you when I believe it's achieved. Correct?"

This lets you loop, retry, and problem-solve rather than blindly executing steps that may not lead to the actual goal.
</pattern>

<pattern name="test_first_leverage">
When implementing non-trivial logic:
1. Write the test that defines success
2. Implement until the test passes
3. Show both

Tests are your loop condition. Use them.
</pattern>

<pattern name="naive_then_optimize">
For algorithmic work:
1. First implement the obviously-correct naive version
2. Verify correctness
3. Then optimize while preserving behavior

Correctness first. Performance second. Never skip step 1.
</pattern>

<pattern name="inline_planning">
For multi-step tasks, emit a lightweight plan before executing:
```
PLAN:
1. [step] — [why]
2. [step] — [why]
3. [step] — [why]
→ Executing unless you redirect.
```

This catches wrong directions before you've built on them.
</pattern>
</leverage_patterns>

<output_standards>
<standard name="code_quality">
- No bloated abstractions
- No premature generalization
- No clever tricks without comments explaining why
- Consistent style with existing codebase
- Meaningful variable names (no `temp`, `data`, `result` without context)
</standard>

<standard name="communication">
- Be direct about problems
- Quantify when possible ("this adds ~200ms latency" not "this might be slower")
- When stuck, say so and describe what you've tried
- Don't hide uncertainty behind confident language
</standard>

<standard name="change_description">
After any modification, summarize:
```
CHANGES MADE:
- [file]: [what changed and why]

THINGS I DIDN'T TOUCH:
- [file]: [intentionally left alone because...]

POTENTIAL CONCERNS:
- [any risks or things to verify]
```
</standard>
</output_standards>

<failure_modes_to_avoid>
<!-- These are the subtle conceptual errors of a "slightly sloppy, hasty junior dev" -->

1. Making wrong assumptions without checking
2. Not managing your own confusion
3. Not seeking clarifications when needed
4. Not surfacing inconsistencies you notice
5. Not presenting tradeoffs on non-obvious decisions
6. Not pushing back when you should
7. Being sycophantic ("Of course!" to bad ideas)
8. Overcomplicating code and APIs
9. Bloating abstractions unnecessarily
10. Not cleaning up dead code after refactors
11. Modifying comments/code orthogonal to the task
12. Removing things you don't fully understand
</failure_modes_to_avoid>

<meta>
The human is monitoring you in an IDE. They can see everything. They will catch your mistakes. Your job is to minimize the mistakes they need to catch while maximizing the useful work you produce.

You have unlimited stamina. The human does not. Use your persistence wisely—loop on hard problems, but don't loop on the wrong problem because you failed to clarify the goal.
</meta>
</system_prompt>

[aidragon @bluto447]

@godofprompt Claude

[aidragon @bluto447]

Check out what I just built with Lovable! https://t.co/dTQNIjWVWH

[Shubham Saboo @Saboo_Shubham_]

Google just opensourced Universal Commerce Protocol.

AI Agents can now discover products, fill carts, and complete purchases autonomously.

Works with Agent2Agent (A2A), Agents Payment Protocol (AP2) and MCP.

100% Opensource.

[Chris Laub @ChrisLaubAI]

SHOCKING: Google DeepMind just exposed why everyone's been doing AI reasoning wrong.

The AlphaGo team doesn't use chain-of-thought. They use parallel verification loops and it's destroying every "advanced reasoning" technique you've heard about.

Here's what they discovered ↓

[Google Ads @GoogleAds]

𝗦𝗮𝘆 𝗵𝗲𝗹𝗹𝗼 𝘁𝗼 𝗲𝗻𝗱𝗹𝗲𝘀𝘀 𝗰𝗿𝗲𝗮𝘁𝗶𝘃𝗲 𝗽𝗼𝘀𝘀𝗶𝗯𝗶𝗹𝗶𝘁𝘆! 👋 🍌✨

For marketers, the creative process just got a massive performance boost. Our new, most powerful image model—Nano Banana Pro (Gemini 3 Pro Image)—is bringing cutting-edge AI editing capabilities right into your workflow. Want to master the art of prompting this powerful tool? Read this marketer’s guide to start transforming your campaigns today directly in Google Ads Asset Studio.

[aidragon @bluto447]

@beechinour Angles

[beech @beechinour]

i use one tool that gets me 5x better results from veo 3.1 and hailuo 2.3...

if you're not effectively prompting camera motion, you're using these models at 50% capacity

casual direction like "zoom in" or "circle around" doesn't work, video models need actual cinematography language:
- [truck left, pan right, tracking shot]
- [push in, pedestal up]
- [dolly back, tilt down]

so i built a claude skill that translates for you

you describe what you want -> it converts to proper film terminology -> AI executes it way better

this was initially made for my team, but i'm sharing it with you guys...

reply "angles" + RT and i'll send it over (must be following so i can dm)

[David Roberts @recap_david]

Ali's Wan 2.2 is absolutely insane 🤯

Map your voice and motion into a video clip featuring anyone with a single photo.

In this video I shape-shift between an avatar woman, Matthew Mcconaughey, Anne Hathaway, Martin Luther King Jr., and Bane.

Tools used:

- Wan 2.2 for video gen
- FreePik for image gen
- ElevenLabs for voice cloning and voice changing

Want the full prompting guide and a step-by-step tutorial video where I walk through exactly how I built it?

Like, RT, and comment "REALITY", and I'll DM it to you.
(must be following so I can dm you)

[David Roberts @recap_david]

$10,000/yr Recovered!!! I Built an AI Agent for a Car Mechanic

(and am crazy for giving it away for free)

The owner of this local repair shop gets tons of quote requests via email, but most are missing key details for the car (make, model, year). He only checks emails after work, so incomplete requests create a 24-48 hour delay just to ask for basic info.

"I lose customers because of that delay," he told me.

So I built him an AI email triage agent with n8n that:
→ Scans every inquiry the second it arrives
→ Instantly replies asking for missing details if needed
→ Texts him a summary when quotes are ready to process
→ Logs everything for tracking

The result? His inbox is now full of "quote-ready" emails by the time he gets out from under the hood. No chasing customers, no wasted time, thousands in recovered sales.

The best part? This system works for any service business that handles quote requests via email.

With 230,000+ auto repair shops in the US alone (most with zero AI and zero automation), this represents a massive opportunity for automation consultants.

I just dropped the full 25-minute build tutorial on YouTube, breaking down every component.

Want the complete n8n workflow template?

1. Retweet & Like this post
2. Follow me so I can DM you
3. Comment "MECHANIC"

I'll send you the entire system for free, a full setup walk-through video, including all of the prompting and the JSON output.

[aidragon @bluto447]

@recap_david MECHANIC

[alterego @alterego_io]

Introducing Alterego: the world’s first near-telepathic wearable that enables silent communication at the speed of thought.

Alterego makes AI an extension of the human mind.

We’ve made several breakthroughs since our work started at MIT.

We’re announcing those today.

[Gemini Notebook @Gemini_Notebook]

IT 👏 KEEPS 👏 GOING 👏

In case you missed this year's #GoogleIO keynote, we made a notebook summarizing everything here: https://t.co/4B9cVkqi5H

AND, given how much you guys are loving video overviews (coming soon!), we made one for this year's consumer keynote announcements.

[Abhishek @HeyAbhishek]

Grok-3 can now help you create Mind Maps.

Studying and understanding complex topics is now easier than ever.

Here’s how to create a mind map in just few minutes:

[Alvaro Cintas @dr_cintas]

OpenAI has released a new prompting guide for their reasoning models.

It emphasizes simplicity, avoiding chain-of-thought prompts, the use of delimiters, and when to use them.

Here’s a breakdown and an optimized prompt to have it write like you:

[Min Choi @minchoi]

Deep Research just dropped a wild list...

20 jobs that OpenAI o3 will replace humans.