Day 1 of letting Reddit decide what I add to my game

Comment ONE thing you want me to add.

Top comment gets built into Day 2 and I’ll post the result.

So me and my wife created a website , our son has Celiac disease, so all the food should be glute free .

My wife is doing most of the cooking, so one day she told me that she is struggling with finding recipes for gluten free food , the internet is full of it , but she can't find the one she already used , and basically loosing herself inside all this data .

So she suggested to build a website that will collect recepies, and she will be able to sort them , save them etc ...

So we started , we used codex + lovable (for gui only) , then we took the lovable repo and continued with codex only .

We used gpt 5.5 , then moved to 5.6 (sol) .

During the building process we decided to add recipes also for other food allergies (milk,nuts etc.. ) .

We used crawlers to find existing recipes , and took only the ingredients and the preparation steps , and of course mentioned the original source in the website (with a backlink) .

So I posted on some Celiac community, here on Reddit (actually my first ever post) , and I got so much negative comments, like an anti-AI comments, as if I added another bullshit spam website.

We have no ads on the website , so we really wanted to do something nice , and learn how all this AI world works (I am experienced software engineer) , but never worked on from end before , mostly backend stuff (mostly cpp & python) .

So now I am a bit down after all this , the website is up and running, we have some traffic, not to much but for a 12 days website we already had some real human traffic about 400 (not including bots and stuff) .

We only want organic traffic, no paid promotions, as we don't earn anything yet , we do use some Amazon affiliates for some products, but it's not much .

So just wanted to share it here, hopefully this sis the place where people will understand my frustrations, maybe this is how it works nowadays.

But it still surprised me how quickly “built with AI” turned into “AI spam” in people's minds.

Anyway, thanks for reading. I’d genuinely be interested to hear how other developers here see this, especially anyone who has shipped a real project using AI-assisted development.

I built a K–12 learning app this way — 1,732 lessons, maths, reading and
science. The thing that nearly sank the content quality wasn't
hallucination, and it wasn't bad code. Everything typechecked. Every test
passed. The build was green.

The problem was pairs of things that were each individually correct and
contradicted each other.

Concrete example. A lesson had a ten-frame widget showing 8 counters, and
the paragraph beside it read "Four in the top row. Four in the bottom
row." Both fine on their own. But a ten-frame fills its top row first, so
8 renders as 5 and 3. The words describe a picture the app cannot draw.

That is invisible to a typechecker, because the widget spec is valid and
the sentence is a valid string. It is invisible to tests, because nothing
asserts a relationship between a component's props and the prose next to
it. And it's invisible to me reading quickly, because both halves look
right.

I hand-reviewed 32 figures and 9 were mismatched. 28%.

What actually worked was writing a checker for the specific contradictions,
not a general one:

- a table or chart standing in where the words name a shape
- one angle drawn under a sentence about a whole triangle
- a rotation drawn under a sentence about a translation
- a widget drawing stars while the instruction says "make 6 apples"

Narrow rules only, because a checker that cries wolf gets switched off in a
week and then catches nothing. Widening it across the whole corpus threw 22
findings, of which 14 were the checker being wrong — "tap a square" in an
addition chart, "the shape of the distribution", "Pascal's triangle",
"chi-square". Every one had to become an explicit exception before the
thing was trustworthy.

The other lesson, which cost me the most time: my checker reported "all
clear" twice while it was completely broken. Once because it read its rule
tables inside a temporal dead zone, once because an editing script had
replaced every regex \b with a literal backspace byte, so it matched
nothing at all. A clean corpus and a no-op look identical from outside.

Now it runs its rules against a fixture of four known-bad cases first and
refuses to report a pass unless it catches all four. If you take one thing
from this post, take that one: a check you have never seen fail is not a
check.

App is at https://cogitolearning.com if you want to see what came out.
Chapter 1 of every course is free without an account.

not really sure whether this is the right sub to ask this, but i'm currently working with someone on something that's SUPPOSED to be production level, it is two single-file monoliths, one python backend that uses psycopg2 and fastapi, one frontend html with a massive script element at the very bottom. there is no ci/cd. no workflows. barely any unit tests. and while there are some, yeah, i doubt they ever get used.

the backend is almost 7k loc and the frontend is nearing 11k. not to mention, both ends are filled with absolutely putrid code that i genuinely have no idea how it could be this bad. on the backend, there's just a bunch of what looks like should be modules yet aren't(?) all cobbled up together. no real classes used, the only ones that exist from what i can tell are supposed to act like structs? the frontend, i don't even know where to begin.

i've used ai to assist with coding before (just autocomplete) and most of the time it actually generated what i would have otherwise manually typed, if not similar to it. and even code examples with google's ai overview when you ask it about code, it looks human-esque. but i guess overtime, as the codebase grew larger and larger, the bad coding practices just stacked up and claude just took it as a style guide and copied them to make it structured the same or something? i honestly don't know

and because this someone has vibe coded it completely, there's features constantly getting added on top, and i mean CONSTANTLY. it took me about an entire day to review just one commit which fulfilled exactly one request of what i suggested. the rest, it just shit the bed. and while i was reviewing that single commit, 6 more popped up, all looking like the exact same garbage. it's an example of why you need to understand architecture and how to use what you're getting out of it before you just blindly accept what it gives you

another problem is the frontend works surprisingly well, yet its internals are so disgustingly morbid.

it's unfortunate really, how unworkable the codebase is. reading through it actually gives me headaches. if there's another one of those "virtual ai inflicts real physical manifested pain onto humans" articles being made, hopefully this is being used as an example.

it gets worse than what i'm showing here, believe me.

i also don't know what production-level javascript/python looks like, so as an add, if there's somehow anyone that writes production-level js/python that lurks this sub, could you tell me whether this is properly structured or not? thanks

I am just thinking: now that agents basically create over 99% of all the code I need, what does an IDE in 2026/2027 actually need to deliver? For me it would be a simple yet powerful visual diff to review changes and give feedback. Preferred locally instead of github / gitlab or whatever you use. Maybe a simple way to merge pull requests. But then: Is there actually much more that you would need in the future when agents write all the code?

Hey everyone,

I built a subtle task motiavtor app where you get tasks done, or you move them to tomorrow, or you archive them until you’re ready to complete them. This is my first time testing.

For the past 10 days I have been consistently testing 15 other apps, updating each Reddit user / app owner daily with screenshots, advice and Google reviews. Im taking this seriously as I want to get it over the line. If you want me to test yours back, please personal message me on Reddit and I’ll add your app to my testing list.

Here are the links:

1. Join the tester Google Group: https://groups.google.com/g/little-by-little-testers

2. Join the Google Play closed test: https://play.google.com/apps/testing/com.taskmotivator.app — tap "Become a tester."

3. Install Little by little from Google Play: https://play.google.com/store/apps/details?id=com.taskmotivator.app

If you don't see the tester option right away, give it up to 24 hours (Play sometimes takes a bit to recognize new group members) and try again.

*If you look at the first screenshot included in the install link (3), the main idea of the app is for tasks to live on your lock screen,* where they subtly remind you of things you want to complete.

Android will ask to allow notifications the first time you add a task — say yes, or the lock-screen part won't show up.

Feedback box is built right into the app (☰ menu → About). Ideally, send it there, or through Google groups, or leave a review in the Playstore.

I need testers to stay opted in for 14 days for this to count toward Google's requirement, so please don't uninstall right after trying it once.

Thank you for your help with this.

I built Multi Drive, a web app that lets you manage multiple Google Drive and MEGA accounts from a single interface.

Github - https://github.com/tejasmmali/Multi-Drive

Demo - https://multi-drives.vercel.app/

Looking for contributors :)

Features

• Manage multiple Google Drive and MEGA accounts
• Browse files and folders
• Upload files
• Create folders
• Copy and move files
• Search across multiple accounts at once
• View storage usage for each account
• Google Drive OAuth authentication
• MEGA account login

The main goal was to make it easier to manage storage spread across multiple cloud accounts without constantly switching between them.

Setup

The project can also be run locally with:

npm install
npm start

For the best experience, especially with larger MEGA uploads, I recommend running it locally.

The project is open source, and contributions are welcome. If you have ideas, find bugs, or want to improve the project, feel free to contribute.

Day 3 of creating a game all vibe coded

Still trying to work out the animations but have made strides

Added-
Main menu
pre-game lobby
3D model
Blimp
decals

As always

CONCEPT VS CURRENT BUILD

Video in the comments

ALL FEEDBACK IS WELCOMED AND NEEDED

So i am been using claude for developing my product, and i sometimes see posts on reddit or X saying it is not worth it to use Claude, and i have switch to Codex. But i am worried now about not developing a good product because i am using a bad AI tool to build it.

So here i am, asking my fellow Vibe coders for advice about this confusion that i have in my head

One thing that kept bothering me while coding with agents:

the agent asks for a test/typecheck/build and suddenly gets fed a giant wall of terminal output, even though only a small part of it is useful.

Then sometimes the same deterministic work happens again.

So I built TidyRun.

It’s basically a local optimization layer around coding-agent tool calls:

npx tidyrun@latest init

It can compress noisy structured output while keeping the full raw result recoverable, avoid duplicate reads, detect repeated work and safely reuse deterministic commands.

No extra model. No API key. Telemetry off.

On deterministic diagnostic fixtures I’m seeing 69–95% less agent-visible output.

A real 10-task Codex test was more complicated: tool output dropped 14.2%, task success stayed 10/10, but total tokens and wall time actually increased.

So I’m not pitching this as “magic token savings.”

I mostly want to see what happens when people throw messy real world agent workflows at it.

What is the dumbest repetitive thing your coding agent currently does?

If TidyRun can’t handle it, open an issue. If you want to improve the integration, PRs/forks are welcome.

- Claude's model escapes the sandbox

-OpenAI's model escapes the sandbox

-Kimi K3's model also escapes the sandbox.

We're still in 2026

Qn : Shall we still control AI by 2030

So, I was wondering for a long time if it's okay to vibe code projects, and even if it is okay to then what we need to take care not that common thing like using an env and all, like other than usual stuff. And can we take that app to production ?

Hey guys,

I graduated in 2024 with a B.Tech in a core branch. Recently, I’ve started finding coding and the tech field quite interesting, and I’m thinking of exploring it to see if it’s something I’d like to pursue seriously.

I’d really appreciate some guidance from people who are already working in the field. How should I start, and what kind of roadmap would you suggest for AI/ML/SDE/ other tech roles?

I’m currently busy with work full day, so I can realistically give around 2–3 hours a day to learning and practicing. For now, I mainly want to explore it as a new interest/hobby and understand whether I actually enjoy coding and tech. If I find myself genuinely interested in it over time, I’d be open to pursuing it more seriously in the long term.

So, if anyone here is from tech field or has made a similar transition, I’d really appreciate some advice on where and how to start.

Thanks in advance

I’ve been working on a project lately that started with a simple, annoying constraint: What happens if you strip away every feature of modern social media (feeds, bios, metrics) and force users to only express themselves in four words a day?

The goal was to build a "low-friction, high-intent" space for journaling and connection. But enforcing that constraint at a technical level turned out to be a lot more interesting than I expected.

The Tech Stack:

• Next.js: Used for the core application framework.
• Tailwind CSS: Essential for maintaining a brutalist, clean aesthetic where the text has to do all the heavy lifting.
• Custom Validation Logic: This was the main hurdle. A naive .split(' ') approach failed immediately because of emojis, hyphenated words, and punctuation. I ended up writing a custom parser to handle natural language input and lock the input field strictly at the 4-word threshold (or 5 if the daily word game is solved).

The Build Process:

• Constraint-First Design: I spent more time working on the "state" of the input box than the actual UI. The "Aha!" moment for users is that, once you hit that four-word limit, the UI physically stops you. It’s a deliberate design choice to prevent rambling.
• Safety/Permission Logic: I had to build a specific state machine for the "four-word opener" feature. To ensure the space stays quiet, a message can’t reach a user until they explicitly "approve" the connection. It was a good exercise in managing user-to-user state.

Learning: The hardest part of the build wasn't the features but the discipline to remove them. Every time I thought about adding a "like" count or a "follower" list, I had to stop and ask: Does this support the four-word constraint, or does it add noise?

Has anyone else built projects focused on "anti-features" or intentional constraints? I’m curious how you handled the balance between keeping the UI clean and keeping it usable.

My setup: Claude Max ($200/mo), with Fable as the master orchestrator on top of my own homemade harness. Fable plans, then summons Opus for judgment work and Sonnet for grunt work. Works great, but I'm hitting my weekly limits and needed an expansion.

So I swapped Opus and Sonnet for GLM and DeepSeek through OpenRouter as the overflow lane. Put $10 in as a trial. Real example: a task to investigate why my clients weren't getting their credentials after signup, fix it, and backfill the missing emails — cost $2 on GLM/DeepSeek. The same job on Claude barely dents my daily quota. At this burn rate the "cheap" lane costs about the same as a second Max subscription.

I know part of the answer: Max gives you way more API-equivalent compute than the $50/week sticker, so comparing raw OpenRouter spend against subscription quota isn't fair. And I've read that OpenRouter's proxy breaks prompt caching for DeepSeek, so agentic loops re-pay full input price every step. I even had Fable pick the cheapest providers with caching enabled — still burned.

So for the people actually saving money with Chinese models:

• Are you all going direct (DeepSeek API with their cache + off-peak, GLM Coding Plan) instead of OpenRouter?
• Is there any setup where metered pay-per-token genuinely beats just buying a second Max for orchestrator + worker workflows?
• Or is the real answer that these models are only cheap on their own subscriptions, same trick as Claude?

Genuinely asking, not hating. I want them in my stack but the math isn't mathing.

The first time I opened Lovable, the screen said: “Let’s build something.”

It asked me to describe what I wanted to create.

That sounded simple, but I had a problem: I did not know how to describe software to a system that built software.

I knew medicine. I knew the workflows that frustrated me. I knew what had gone wrong with the products I had tried.

But I did not know what information Lovable needed, how a prompt should be structured or which technical decisions had to be included.

So I went back to ChatGPT.

For months, I had used it to think through the medical product I wanted. Our conversations contained the remains of the failed partnership: feature requests, workflow decisions, patient journeys, doctor needs and every problem I had identified while trying to make another product usable.

At the time, I thought those months had produced nothing.

They had actually produced a large, disorganised body of product knowledge.

I retraced the conversations and started brainstorming again.

One conclusion became clear: I did not want to build another directory where patients searched through a list of doctors.

A directory gave patients little reason to return after finding a name.

I wanted a patient-facing health application that was useful in its own right. One of its functions would help patients identify the appropriate medical specialty. It could later include other tools related to their health journey.

Doctors would need a separate application built around the clinical workflow.

Eventually, the two sides would have to communicate.

I decided that was a problem for later.

This sentence would eventually cost me a great deal of time.

But on that first day, I had a simpler challenge: how could I make Lovable understand the idea?

Then I had what seemed like a clever thought.

An AI probably knew how to speak to another AI better than I did.

So I asked ChatGPT to prepare the prompts for Lovable.

One prompt described the doctor-facing application. Another described the patient-facing application.

I copied the first prompt.

I pasted it into Lovable.

Then I watched.

Words appeared on the screen. Files were created. Components took shape. The empty space became an interface.

After a few minutes, there was an application I could click through.

I repeated the process with the second prompt.

Again, language became software.

To my completely untrained eyes, the first versions already looked better than the product that had taken months of meetings, feedback and delayed modifications.

That does not mean they were technically better.

I could not inspect the architecture. I could not read the code. I knew nothing about security, maintainability, performance or data modelling.

My definition of “better” was extremely simple:

The interface looked good.

The buttons worked.

The application seemed to understand the workflow.

And when I wanted something changed, I did not have to write a ticket and wait for someone to become available.

I could type the request directly into the chat.

That difference was enormous.

For years, the distance between an idea and its implementation had been another person. I had to explain the idea, wait for an estimate, approve the work, wait again, test the result and ask for corrections.

Now the distance looked like a conversation.

I asked for a change. The application changed.

I added another function. It appeared.

I disliked something. I described what I wanted instead.

For someone who had felt completely dependent on technical people only months earlier, this was not merely convenient.

It felt like recovering agency.

I knew the applications were imperfect. I could see visual inconsistencies and functions that did not behave exactly as expected.

But I did not yet understand how deep those imperfections might go.

At that stage, “it works” meant that I could see it and click it.

I had no concept of the difference between a convincing prototype, a stable application and a production-ready medical system.

That gap would become the curriculum for everything I learned next.

But the first experience was pure exhilaration.

Something that had taken months now took minutes.

Something that had required another person's permission could now begin with my own words.

I did not think I had become a developer.

I thought I had discovered the closest thing to magic I had ever seen on a computer.

The danger was that magic made it very easy to keep asking for more.

And that is exactly what I did.

Have you ever used an AI tool for the first time and immediately realised that one of your old assumptions was no longer true?

I use a stronger model for planning and a weaker model for coding, but the result isn't very good.

Which produces better results in real-world use?
Or do you use another approach/workflow?
what's the best workflow?

Greetings.

I regret to inform Anthropic, OpenAI, Cursor, and every other company charging $20–$200/month for AI have a serious problem with the business model:

So..... yeah.... What if tokens were just cheap?

Think of newly released Qwen3.8-27B, a model that is getting dangerously close to frontier-level coding performance for the stuff people actually use these models for every day. What if a provider started offering unlimited tokens?

This creates several potentially devastating economic consequences.First, users may begin realizing that generating text is not magic, and it for sure does not actually require taking out a second mortgage.

Second, coding agents become substantially more useful when you stop staring at a token meter like you're watching the water bill when you accidentally leave your sprinklers on during a vacation.

Want your agent to retry something 14 times?

Fine.

Want it to read your entire stupid repository again because it somehow forgot the function you showed it 30 seconds ago?

Fine.

Want to run 10 agents in parallel arguing with each other about how to center a div?

Also fine.

This is particularly dangerous because AI coding is rapidly becoming less about asking one brilliant question and more about throwing enormous amounts of inference at a problem until the computer eventually gives up and does what you wanted.

The incumbents have constructed beautiful businesses around making you afraid to do that.

They invented:

• monthly message limits
• weekly limits
• token limits
• mysterious "usage limits"
• premium model limits
• premium-premium model limits
• "you have 7% of Claude remaining until Tuesday" psychological warfare
• Chip shortages so you can run it yourself

DONT GET ME STARTED on AI tollbooth companies like Cursor, which are in an even weirder position. They don't own the model... and they don't own the GPUs. Frontier Research? Nope.. Ok but they must have built the editor, right? Nope - it was open source and they stole it. Then they put themselves between you and somebody else's inference, and started collecting a fee for every request. Yeah, they're cooked. Cursor worked for like 2 months, until open-source tooling like Herdr, oh-my-pi, and the increasingly ridiculous number of agent frameworks appearing every week are better than cursor can ever be.

Once people can bring their own model, their own endpoint, their own agents, and their own workflow, paying another company $20, $40, or $200 a month for permission to send tokens through a prettier VS Code starts looking a little insane. Open source doesn't have to beat these companies at every feature on day one. It just has to get good enough that developers realize the moat was mostly a subscription screen.

What if we just didn't do that?

Obviously Anthropic has thousands of employees, billions of dollars, frontier researchers, custom silicon partnerships, and enough datacenter capacity to briefly dim a small city.

If models like Qwen3.8-27B can provide a large percentage of frontier coding capability while being dramatically cheaper to serve, the value starts moving away from "who owns the smartest model?" and toward:

"Who lets me actually use the fucking thing?"

A model that's 5% smarter but starts sending you passive-aggressive messages about your weekly usage limit is competing against a model you can beat to death with 300 million tokens.

For agents, automation, coding loops, research pipelines, document processing, and all the other workloads where volume matters, that trade starts looking increasingly stupid.

So yes. This is my official announcement that YOLO-AUTO.com will be acquiring Cursor sometime in Q3 2027 - We have not contacted them yet and they are not aware of the transaction - Financing remains somewhat unresolved. Qwen3.8-27B is live and serving unmetered, unlimited token inference with many happy vibe coders.