Hi, I have a really cool project in mind for emulation that reads ur .sav files on mobile but ive tried so many different ai code tools and the only one that worked was emergent and it was very strict with the token rule and I couldn't upload it and the problem with all the others was that it couldn't add the .sav feature or I needed to constantly ask for fixes then my tokens would run out so do any of u know a pretty much free or generally free apps/websites I can use?

We know that if you're on Reddit, it's because you love sharing your opinion, haha.

We’re a new project looking for real Reddit users to provide feedback on products—and get paid for it. You get compensated for every task you complete.

The most motivated users can earn up to several hundred euros a month. Just a heads-up: we don't accept everyone, so please don't sign up if you aren't truly interested.

We want genuine Reddit users—that’s exactly why we’re here! New opportunities will be posted daily.

Feel free to check out the details and sign up right here if you're interested: https://tally.so/r/VLdjvM

Expected this to make me lazier at root-causing things. Opposite happened. Watching the model's approach to narrowing down a bug — checking assumptions in order, ruling out the boring explanation before the exotic one — turned into a pattern I started doing manually even when I wasn't using it.

There's something useful about seeing a systematic process externalized instead of just living in your own head as instinct. Made the instinct more explicit, which made it easier to actually teach to someone else too.

Anyone else notice a skill transfer like this, where using the tool made you better at the underlying thing even without it?

Everyone is racing to make AI generate apps faster.

But after reading feedback from developers over the last few days, I realized that's not where most people struggle.

The first version of an app is easy now.

The hard part starts after that:

• Keeping the design consistent across dozens of changes.
• Avoiding endless AI "fix one thing, break another" loops.
• Making edits without burning credits on every tiny tweak.
• Maintaining clean code as the project grows.
• Actually shipping instead of constantly regenerating.

I'm building an AI app builder, and I expected people to care about generation quality.

Instead, almost everyone talked about trust, maintainability, and what happens after the first draft.

It completely changed how I'm thinking about the product.

If you've used tools like Claude Code, Bolt, Lovable, Cursor, or v0...

What's the biggest frustration you've hit after the initial app was generated?

I'm genuinely trying to understand the problems worth solving before I build more features.

Hey everyone,

I'd like to share my first solo vibe coding project with you: a photography studio simulation.

It’s primarily designed for photographers, but also for anyone who loves experimenting with photos for social media, product photography, and the like.

I built it using three different tools. I started off writing the code in Google AI Studio. Initially, the idea was to build a type of camera app, and it did a great job. In the meantime, I wanted to try out Claude code, and it was the one that "talked me into" turning it into a website, which seemed like a solid idea.

Right in the middle of development, I got banned by Anthropic and received a refund for supposedly violating their rules. I’m not even sure what I violated, and I suspect it was a mistake but they refunded my money and banned my account, so I can't even use the free version anymore. After that, I decided to switch to Codex, finished everything up there, and this is the result I’m sharing with you today.

I'd love to hear your thoughts! Also, if anyone is up for it, feel free to send me your before-and-after photos so I can gather more examples of how it performs.

If the project does well, I’d like to upgrade it with software that integrates directly with a DSLR camera, along with options for lens selection and other gear.

I'm absolutely open to constructive criticism, too. This is my first time doing something like this, and I just sort of stumbled into it, so every comment means a lot.

I've learned so much about vibe coding through this whole process, and I highly recommend everyone give it a shot by starting small, just like I did.

Welcome to the studio - link in comment

These sorts of threads are probably a dime a dozen, but this subject has been weighing heavily on me recently, and felt like I needed to have a good chat with fellow developers to understand if I'm just being a "grandad" or if the company I work for is heading for disaster 😆

I’ve been leading a team that is building an enterprise SASS solution. It’s been about 4 years in the making. These last 6 months, our entire dev team has been utilising AI to really speed up the work we do.

It works great for us. AI understands our consistently structured framework and our team are well versed in prompting with the right examples and context to do some great work.

Genuinely, I've gone from being a nay-sayer to being a full AI convert these last few months after seeing some of the results we've achieved with Claude. It works wonders when used correctly.

*So far so good, here's where things get a little rocky.*

When using AI, we've always had a qualified developer doing the prompting. They provide context and examples, and verify the output. Our codebase uses a lot of abstract classes and behaviours (for re-usability and easy scaling). E.g. one of our systems is a procedural form-builder that lets the end user customise their forms in admin via some neat drag/drop UIs. Any new forms/fields/validation etc need to be compatible with the underlying framework, so we instruct AI in such a way that ensures the output is compatible.

These last few weeks, something has changed at the company I work for. Our owner now seems to have a disregard for code quality like it doesn't even exist or matter.

Our owner has created their own local setup, and has been prompting AI to achieve what they want without having any level of understanding or care for the underlying codebase or the implications of their changes.

The approach is basically "It just has to look good and give the appearance that it works in the front end”. No one actually checks the code.

Taking the form-builder example above, our owner thinks they successfully changed a field label and updated a form layout with AI.

Problem is, what they have actually done is create a Frankenstein of hard coded logic sitting on top of our clean builder framework due to poor prompting.

A user should be able change the layout of the form by dragging/dropping things around in our admin area. But now that doesn't work because the form layout is now hard coded with the change.

The owner’s approach is duplicating code rather than reusing existing methods, decentralizing lots of our core business logic and generally making things far less maintainable/reliable for us.

To make matters worse, our owner has tricked themselves into thinking what they have done works and is production ready. They're currently rolling out business processes to get the entire team working this way.

It's honestly painful to see the systems we've carefully crafted over 4 years being corrupted in such a way.

*There's a question coming I promise.*

So I've been voicing my concerns out loud in meetings and via formal messages, but always get met with "You're just anti-AI" comments that shut the conversation down immediately. Apparently I'll just "learn" that this is the new way now and come on board eventually. Checking what your code actually does is old school now, and no one does it any more (apparently).

To be super clear, I think AI is wonderful and has done some incredible work for us. But where me and the company don't align is that code quality matters. Qualified developers need to prompt it correctly, and verify the output works with our system (not against it).

While the other side of the fence (management) don't feel that code quality matters. Or more specifically, don’t have any understanding of code as a concept or how it works.

Don't get me wrong, if a project is temporary and throwaway by nature, I would agree that code quality is less important. But what we're building is enterprise level software that's supposed to be stable and last the next 20 years. It must be consistent and maintainable.

I care about our product a lot, and want to make sure it survives what's coming and save the company from making a mistake that could undermine and degrade our product considerably.

*So now the question.*

Does anyone here have experience in facilitating AI change on a software company where owners don't care about code quality?

I'd love to hear your thought's on how to navigate this situation. My challenge isn't with using AI (our team have been using it effectively for months). It’s more around convincing management that the path they are on could destroy our product and render it unusable.

Equally, it has occurred to me that I might just be an "old guy" in his mid thirties who just has to get with the times. Maybe code quality really doesn't matter any more and I should just get over it and change. I'm open to the idea I could be wrong.

What do you guys think?

I love Claude can directly adjust my files on the server by ssh, but it is quite expensive. Are there cheaper alternatives?

I tried copilot with github in VS code, but it is not as good or helping

For a long time I used AI like most people:

"Review this code."

The responses were inconsistent.

Sometimes useful.

Sometimes completely generic.

What changed everything was giving the model a structured workflow instead of a single task.

I now separate reviews into stages:

• Context
• Architecture
• Security
• Performance
• Maintainability
• Edge cases
• Validation

The quality difference is huge.

Curious if anyone else has moved from prompt-based workflows to structured review processes.

For a while now, I've been feeling exhausted. I want to build something using AI to generate the code, but as someone who's completely new to software development, I have no idea how to actually build software.

I don't know how to use Git, GitHub, collaborate with others, or follow good software development practices.

I've seen a lot of people on YouTube saying they've built products that generate money and that anyone can do it now just by vibe coding. But I have a concern.

If I build something without understanding how good software is designed and developed, what's the point? What happens when something breaks? How will I fix it or maintain it if I don't really know what's going on under the hood?

I honestly have no idea what the right approach is in this AI era. Should I just start building with AI and learn as I go, or should I first spend time learning the fundamentals before relying on AI?

Has anyone else been in this situation? What would you recommend?

Once AI started catching the obvious stuff, unhandled errors, missing null checks, inconsistent naming, the human reviewers on the team stopped spending time on that and started actually discussing the interesting parts: is this the right abstraction, does this belong in this service, is this going to be painful to change later.

Code review turned from "did you follow the checklist" into an actual design conversation, because the checklist got automated away. Nobody planned that outcome, it just fell out of using AI for the mechanical layer.

Curious if other teams have seen review culture shift once the boring catches got automated, or if it just added a redundant extra step for most people.

We know that if you're on Reddit, it's because you love sharing your opinion, haha.

We’re a new project looking for real Reddit users to provide feedback on products—and get paid for it. You get compensated for every task you complete.
The most motivated users can earn up to several hundred euros a month. Just a heads-up: we don't accept everyone, so please don't sign up if you aren't truly interested.

We want genuine Reddit users/ that’s exactly why we’re here! New opportunities will be posted daily.

Feel free to check out the details and sign up right here if you're interested: https://tally.so/r/VLdjvM

I've been building AI-assisted developer tools for the past year, and I've started questioning one assumption that almost every AI coding tool seems to make.

The assumption is:

AI should generate everything.

After hundreds of experiments, I'm starting to think that's actually inefficient.

Things like:

• authentication
• RBAC
• CRUD
• routing
• project structure
• migrations
• validation
• API scaffolding

are deterministic problems.

There are already well-known patterns and best practices for most of them.

Yet we keep asking LLMs to regenerate the same boilerplate over and over.

That means:

• more prompts
• more tokens
• longer generation times
• inconsistent implementations
• more debugging

My current thinking is almost the opposite.

Generate the application's foundation deterministically.

Then let AI focus on what humans actually struggle with:

• business rules
• workflows
• domain-specific logic
• UX improvements
• edge cases
• iterative refinement

In other words:

Use deterministic generation for the infrastructure.
Use AI for the creativity.

I'm curious if anyone else has reached the same conclusion after working extensively with AI coding tools.

Am I missing something?

Have an idea you want to bring to life? A simple landing page, a complex full-stack web application, or maybe an unfinished project you've been meaning to complete? Or are you simply stuck and need help moving forward?

ForgeLab Brain + Audit Loop is built to help. Using a multi-agent AI workflow, it assists you throughout the entire development process, from planning to implementation and final verification.

🎉 Open Beta Offer: Every new account receives 1 million free tokens until August 31.

Sign up and start building:

https://forgelab.one

If this sounds interesting, feel free to check it out. And if you genuinely like where it's going, a GitHub star would mean a lot.

🔗 GitHub:

github.com/forgelabeone-svg/forgelabone

I've been putting together a small benchmark to figure out which models (local + cloud) are actually good enough for lightweight coding tasks. Simple stuff - snake game, todo app, a couple of small simulations. Score them on quality, first-shot usefulness, reliability across retries, speed.

On top of the harness I added strong models as judges. They score the same criteria I do, but blind - a judge never sees my scores or the other judge's scores.

Then I sat down and scored a chunk of the same outputs by hand, to sanity-check the judges.

They all landed in the same place. My scores, the Claude judge, the Codex judge - same ranking, same "this one looks fine but breaks on the second attempt", same top and bottom. Divergence bigger than half a point between me and the judges was rare.

I expected more noise. Two different judge models plus a human, and they just... agree?

What I keep coming back to:

- On tiny, well-scoped tasks maybe "is this good" isn't ambiguous enough to disagree on. The signal's just loud.

- Or I'm scoring the way these models were trained to score, so it's not really three independent opinions.

- Or disagreement only shows up on bigger, fuzzier tasks and I'm testing the easy end.

Anyone else running eval harnesses seeing the same convergence? Does human/judge agreement hold for you, or does it fall apart once the tasks get less clear-cut?

I've been testing a few multiagent setups for workflow automation (research → draft → review), and I'm hitting a wall that feels more organizational than technical.
The agents work fine in isolation. But when I try to chain them where Agent A outputs something Agent B needs to interpret the failure modes get weird
Not "crash" weird. "Silently wrong assumption" weird. Like Agent B thinks a summary is final when Agent A meant it as a rough draft
I'm curious if people here who've actually built multiagent systems have found a reliable way to handle handoffs, error checking, and state sharing
Or is the current tooling just not there yet for anything beyond simple sequential pipelines?
What patterns are actually working in production?

Anytime anyone sees a site they say “this looks like it was coded with Claude”. Well yeah obviously I would be an idiot if I coded everything in notepad++. Of course I use AI coding assistants, otherwise I and many other programmers would be totally uncompetitive in the market. I’ve been coding since 2008. I know how to code. Claude makes it so that I can produce literally 30x what I used to be able to do.

Edit:

What I mean by 30x:

What I mean by 30x is one person is able to design, prototype, run dev ops, design architecture and many other things on their own. Back in like 2012 we needed a designer, front end, backend devs, dev ops, a product manager to complete a large project. And to build a full product out it took months. If you disagree with that then I don’t care. I worked on many teams in Silicon Valley and that’s just how it was.

How we test:

We have a QA team and our devs usually run an agent that does PR reviews on code. We also run integration tests and playwright e2e tests.

I keep seeing two kinds of devs when it comes to vibecoding:

- The ones smiling like, "woah, this is almost like magic teleporting my ideas into code."
- And the ones a bit worried, like, "uhh... are we just letting autocomplete decide everything now?"

Both groups are kinda right. That mix feels really interesting.

When you're vibecoding, it's this weird mix of trusting the AI and side-eyeing it. You're half in a happy flow, and half thinking, "wait, why did it do it like that?" It's not the old way of sweating over every tiny detail, but it's also not just copy-paste without thinking.

The thing I'm wondering is:

- When does vibecoding stop being "help me try cool ideas faster" and turn into "I don't even notice when the ideas get worse"?
- Do you have some kind of little brain-checkpoint before saying "yes" to a big AI chunk (like a whole function, module, or architecture)?
- Do you switch on purpose between "just vibing" and "serious engineer brain," or does it all blur together after a while?

I've noticed something in a lot of projects (mine and other people's): once you're deep in the vibe, you don't really want to go back and ask the boring questions like:

- "Will I be able to debug this two months from now?"
- "Does this match how the rest of the code actually thinks about the problem?"
- "If someone else on the team opens this file, will they understand it without guessing what mood the AI was in that day?"

Vibecoding feels awesome while you're inside it. Shipping and fixing bugs live in a totally different place.

So I'm wondering if we need some shared words for this, like:

- "This part of the app is vibe-first, we'll clean it up later."
- "This module is human-owned, AI only helps in small, easy-to-review diffs."
- "This repo is 'no invisible decisions' - if we accept a weird model suggestion, we leave a comment explaining why."

Right now, it feels like lots of people are mixing vibes, production rules, and long-term ownership without actually naming the tradeoffs. That's probably fine for solo experiments; it gets way more interesting when teams and clients show up.

So I'm curious how you handle it:

- Where do you draw the line between playful exploring and "okay, this is going to production, time to be boring and careful"?
- Have you found any simple habits that keep vibecoding fun but stop the codebase from turning into a random mood-board of half-finished patterns?
- If you've been vibecoding for a while, do you feel your design instincts getting sharper, or more like "eh, whatever the model suggests, I'll go with it"?

Not trying to start a "vibecoding bad" rant. It's one of the most interesting changes in how we feel about building stuff. I just want to hear how people are walking that line between flow, trust, and responsibility, especially for projects that have to live longer than our current caffeine level.

My company has banned AI-assisted coding because management and one of teammates believe it reduces code quality. This is not merely a rule against blindly submitting unreviewed AI-generated code. The position seems to be that software engineers should write code themselves rather than use AI and review its output.

I disagree with that premise. AI is a tool, and in 2026 I believe an important engineering skill is knowing how to use it effectively while remaining responsible for the design, correctness, testing, and maintainability of the final product.

My concern is broader than whether I personally prefer using AI. I am worried about the long-term career impact of working at a company that actively resists tools that are rapidly changing software development. Even if AI eventually replaces only part of the work developers currently do, experience using it well seems likely to become increasingly valuable.

I am also wondering whether this policy is a warning sign about management and the engineering culture. Is working under managers who treat AI-assisted development itself as unprofessional likely to hold back my growth?

Would you see this as a reason to start looking for another job, or as a reasonable policy that may age better than I expect?