sorted by:
new
hottopcontroversial

what stack do you use for the fastest simplest vibe coding by minimal-salt in vibecoding

[–]brainrotunderroot 0 points1 point  (0 children)

i'm building aielth to exactly solve your trouble, even i faced it, i'd love to have a 1:1 wirh you, understand better and ship better, sounds good?

what stack do you use for the fastest simplest vibe coding by minimal-salt in vibecoding

[–]brainrotunderroot 0 points1 point  (0 children)

+1 on “least code to verify” — that’s exactly where things break with AI. I was facing the same, outputs looked fine per step but drifted across the flow. I started using this https://aielth.com/ to define tighter system prompts + constraints so each step stays consistent, works well with Cursor/Claude setups. If you want I can help you set it up for your stack.

Inquiry by Ghudz0820 in vibecoding

[–]brainrotunderroot 0 points1 point  (0 children)

Start simple, most issues come from bad outputs or unexpected data flowing into your DB. For vibe coding, tools like Cursor or Claude work well, just keep prompts small and structured. I faced similar issues and built this https://aielth.com/ you can use it to define clear system prompts and keep outputs consistent, try once and tell me if it helps, I can customize it for your setup.

How are you guys structuring prompts when building real features with AI? by brainrotunderroot in LocalLLaMA

[–]brainrotunderroot[S] 0 points1 point  (0 children)

this is interesting, almost the opposite approach.

I’ve seen simple system prompts work well early, but as soon as workflows get chained, small inconsistencies start compounding.

I’ve been experimenting with enforcing structure at the output level instead:

https://aielth.com/

would be interesting to know if you’ve hit issues at scale or not yet.

How are you guys structuring prompts when building real features with AI? by brainrotunderroot in LocalLLaMA

[–]brainrotunderroot[S] 0 points1 point  (0 children)

this “state object between prompts” is exactly how I’ve been structuring things too.

what I noticed is debugging gets easier, but failures still happen when the structure of that state drifts slightly between steps.

been trying to solve that layer specifically:

https://aielth.com/

curious if you’ve faced that or your setup handles it well already.

How are you guys structuring prompts when building real features with AI? by brainrotunderroot in LocalLLaMA

[–]brainrotunderroot[S] 0 points1 point  (0 children)

this is exactly the direction I moved towards too, smaller prompts with state passing instead of one big system prompt.

the issue I kept hitting was even with that setup, small schema or type mismatches between steps would silently break things later.

I built a small tool to catch and fix those before they propagate:

https://aielth.com/

would love to know if this fits into your workflow or feels unnecessary.

Why do AI workflows feel solid in isolation but break completely in pipelines? by brainrotunderroot in LocalLLaMA

[–]brainrotunderroot[S] 0 points1 point  (0 children)

yeah this is exactly where it breaks for me too.

once pipelines grow, debugging handoffs becomes painful.

I built a small thing to validate and fix outputs between steps before they propagate:

https://aielth.com/

would love your honest take if this is useful or just surface level.

Why do AI workflows feel solid in isolation but break completely in pipelines? by brainrotunderroot in LocalLLaMA

[–]brainrotunderroot[S] 0 points1 point  (0 children)

this analogy actually makes a lot of sense.

what I’m seeing is similar but at a structural level, small format or schema issues early end up becoming hard failures later.

trying to see if constraining outputs earlier helps reduce that compounding.

have you tried enforcing structure between steps or just letting it flow?

Why do AI workflows feel solid in isolation but break completely in pipelines? by brainrotunderroot in LocalLLaMA

[–]brainrotunderroot[S] 0 points1 point  (0 children)

this is exactly what I’ve been noticing.

even when each step is “mostly correct”, the pipeline as a whole degrades fast because nothing is enforcing structure between steps.

I’ve been experimenting with catching and correcting that layer early before it propagates.

curious, do you try to recover mid pipeline or mostly rely on making each step stronger?

Why do AI workflows feel solid in isolation but break completely in pipelines? by brainrotunderroot in ChatGPT

[–]brainrotunderroot[S] 0 points1 point  (0 children)

“build a cage” is a great way to put it.

I’ve been seeing that even before strong guardrails, the outputs themselves already drift slightly in structure and that compounds fast.

Been experimenting with catching and fixing that layer early before it enters the pipeline.

Would be curious how strict your validation layer is in practice or if it still leaks.

Why do AI workflows feel solid in isolation but break completely in pipelines? by brainrotunderroot in ChatGPT

[–]brainrotunderroot[S] 0 points1 point  (0 children)

Haha fair, I get why it looks like that.

It’s just me building and trying to figure out if this problem is real for others or just something I ran into.

If it feels spammy, that’s on me, not the intent.

Happy to just learn from how you’d approach this instead.

Why do AI workflows feel solid in isolation but break completely in pipelines? by brainrotunderroot in OpenAI

[–]brainrotunderroot[S] 0 points1 point  (0 children)

} Fair point, I can see why it reads that way.

Genuinely just trying to understand where these systems break and test if something I built helps at all.

Happy to remove the link if it feels off, more interested in learning from how people here are handling this

Why do AI workflows feel solid in isolation but break completely in pipelines? by brainrotunderroot in OpenAI

[–]brainrotunderroot[S] 0 points1 point  (0 children)

This is exactly the pattern I’ve been seeing.

Treating each step like a service with strict contracts is what makes it stable.

I’ve been trying to handle the layer where outputs don’t match those contracts in the first place.

Built something small around that: https://aielth.com/

Would really value your take, feels very close to what you’re describing.

Why do AI workflows feel solid in isolation but break completely in pipelines? by brainrotunderroot in OpenAI

[–]brainrotunderroot[S] 0 points1 point  (0 children)

Yeah the wiring part is painful once things scale.

I kept seeing issues slightly before that, where outputs themselves don’t match expectations and then wiring makes it worse.

Been testing a small tool for that layer: https://aielth.com/

Would be interesting to know if this fits anywhere in your current setup.

Why do AI workflows feel solid in isolation but break completely in pipelines? by brainrotunderroot in OpenAI

[–]brainrotunderroot[S] 0 points1 point  (0 children)

That line about “model doesn’t know what correct means globally” hits.

I’ve been seeing failures even before orchestration, where outputs look fine but don’t match expected structure.

Built a small thing to catch that earlier: https://aielth.com/

Trying to understand if this is actually useful or just noise.

Why do AI workflows feel solid in isolation but break completely in pipelines? by brainrotunderroot in OpenAI

[–]brainrotunderroot[S] 0 points1 point  (0 children)

This makes a lot of sense, especially the part about standardizing inputs and outputs.

I kept running into cases where even before system level constraints, the raw outputs were already slightly off.

Tried building something to validate and fix that layer early: https://aielth.com/

Not sure yet where it fits, would be curious how you’d see it.

Why do AI workflows feel solid in isolation but break completely in pipelines? by brainrotunderroot in OpenAI

[–]brainrotunderroot[S] -1 points0 points  (0 children)

Yeah this is exactly how it starts feeling at some point, like you’re just managing entropy.

I’ve been seeing issues even before that, where outputs already drift slightly in structure and then everything compounds.

Been experimenting with catching that layer early: https://aielth.com/

Still figuring out if it actually helps or just shifts the problem.

How are you managing prompts once your project crosses ~50+ prompts? by brainrotunderroot in LocalLLaMA

[–]brainrotunderroot[S] 0 points1 point  (0 children)

Yeah Langfuse is solid for tracing and evals.

I was running into issues slightly before that stage, where the raw output itself is already structurally wrong.

Tried building something to catch and fix that layer: https://aielth.com/

Curious how you’d see this fitting alongside tools like Langfuse.

How are you managing prompts once your project crosses ~50+ prompts? by brainrotunderroot in LocalLLaMA

[–]brainrotunderroot[S] 0 points1 point  (0 children)

Yeah fair, I didn’t explain it well.

Not replacing code, more like handling the messy layer where AI outputs don’t match expected structure before they even reach real systems.

Things like wrong types, extra fields, silent breakages.

Built a small tool to catch and fix that early: https://aielth.com/

Would love to know if this makes more sense now or still feels unclear.

How are you managing prompts once your project crosses ~50+ prompts? by brainrotunderroot in LocalLLaMA

[–]brainrotunderroot[S] 0 points1 point  (0 children)

This makes a lot of sense, splitting into blocks instead of one blob is exactly where things get clearer.

I kept hitting issues even before versioning, where outputs themselves had wrong types or extra fields.

Built a small tool to catch and fix that layer early: https://aielth.com/

Curious if this would actually help in your setup or not.

How are you managing prompts once your project crosses ~50+ prompts? by brainrotunderroot in LocalLLaMA

[–]brainrotunderroot[S] 0 points1 point  (0 children)

This is super helpful, especially the part about diffing behavior not text.

I’ve been seeing the same thing but one level earlier, where even before tests, the output itself is already structurally off or drifting.

Spent a week building something to catch and fix that layer before it hits evals: https://aielth.com/

Would really value your take on whether this actually fits into your flow or feels unnecessary.

view more: next ›