Yep, the title says it all, and if you don't believe me, have a look https://x.com/im_dimneo/status/2...
Try it yourself, and let me know what else you got the AI to do for you.

Finally showed my cofounder's technical friend the app I'd been building solo with Claude Code for two months. I was proud of it, it worked, users were paying for it, I felt like a real founder walking him through the codebase.

He got quiet about four minutes in. Not rude about it, just quiet in that specific way where you can tell someone's recalculating their opinion of you in real time. Eventually asked why there were three different ways of handling API calls scattered across the codebase, and I didn't have an answer beyond "that's probably just whatever the agent decided each time I asked for something new."

Didn't feel great. The app still works, still makes money, still solves the problem it was built for. But something about watching someone who actually knows the craft better than me raise an eyebrow at it made me feel like a fraud for about a week, even though nothing about the product itself had changed.

Has this happened to you, showing your vibecoded work to someone with real engineering chops? What did they catch that you'd never have caught yourself, and did it actually change how you build going forward, or did you just quietly feel bad about it and move on like I did?

been seeing a wave of "cloud for your agent's tools" and "managed agent" products launching lately, and it's making me think about a question I don't have a good answer to yet - when you connect an agent to something, do you scope its access per-task and revoke after, or does it usually just end up with broad standing credentials because that's less setup friction? I keep defaulting to the convenient broad-access option and telling myself I'll tighten it later, which is obviously not a real plan. curious what other people actually do in practice, not what they'd say in a security review.

Quick question for frontend devs using tools like v0, Claude, or Cursor. When you get a new Figma design, what's your actual entry point now?

I used to start by setting up component state, props, and styling manually to keep things clean. Last week I tried just feeding screenshots and exported SVGs directly to the AI to spin up the UI instantly. It got me 80% there in 5 minutes, but the generated CSS was a messy soup of arbitrary Tailwind utility classes that took an hour to clean up. Curious how many of you are fully automating the UI handoff vs manually building the core markup first and then using AI for the logic.

Like a lot of you, my API bills have been crazy lately from feeding entire directories and massive logs into the context window for hours.

I noticed a structural loophole in how models are priced: text tokens are billed by character density, but vision tokens are billed by flat image dimensions.

I started taking my massive text payloads and converting them into heavily compressed, high-density PNGs before uploading them to Claude and Gemini. It forces the model to use its OCR, and it actually drops the context cost by about 60% while retaining perfect accuracy.

Has anyone else experimented with multimodal hacks like this to save on API credits, or are you mostly relying on RAG and prompt trimming to keep costs down?

Getting a prototype up and running takes virtually no time now but getting random people to actually stay around is still a struggle.

I can push out a working app over a Saturday night but then it just sits there with zero traffic unless i constantly push it manually.

Where are you guys spending most of your daily energy if you aren't stuck fixing code all day?

Been in a thread lately about the "context tax" of re-explaining project state to an agent every session, and it made me realize the harder problem for me isn't memory, it's trust in the agent's own status reports.

When an agent says "fixed it, tests pass" or "yes that endpoint handles that case," how much do you actually check versus just believing it and moving on? I've gotten burned a couple times by an agent confidently describing behavior it never actually verified, it just pattern-matched to what a fix usually looks like.

I ve been experimenting a lot with AI tools like V0, Lovable, and Bolt.new to build small products and prototypes.

One pattern keeps showing up: most ideas don t fail because the idea is bad. They fail because the prompt is vague, confusing, or incomplete.

AI isn t a mind reader; it does exactly what you ask. If your prompt is fuzzy, your output will be too.

For example, I recently built PublicWall off a single well-structured prompt. Before that, I wasted hours on iterations that were mostly me not clarifying what I actually wanted the AI to do.

Every agent I use has some form of plan mode. I read the plan, say yes, and then somewhere in implementation it drifts a file it was not meant to touch, a step it decided was unnecessary, a "done" that covers half the plan. On one feature I asked it to check its own work against the plan roughly thirty times.

What I do now: write the spec first, from the actual repo, approve that, and give the agent only the approved document. Review becomes a comparison. It mostly holds, but the last check is still me.

What do you do tighter prompts, smaller tasks, a second agent as reviewer, or have you just accepted the drift?

Claude writes the table-based HTML layout -> ChatGPT checks Outlook rendering quirks -> Perplexity verifies dark-mode CSS compatibility

HTML emails feel like coding in 1999 tables inside tables, inline CSS everywhere and Outlook breaking every single button you design!

One AI generates modern CSS flexbox layouts that look amazing in Apple Mail but look totally destroyed in desktop Outlook, while another writes bulletproof legacy HTML that looks boring on dark mode mobile clients. Combining their inputs gets me templates that actually render everywhere.
How do you tackle email coding with AI: single prompt, generator + tester, or multi-model passes?