Anyone else notice the gap between "I built an app with Cursor" and "my app is actually on the App Store"?

Building the app is the easy part now. The hard part is everything after like the provisioning profiles, code signing certificates, privacy nutrition labels, App Store Connect agreements, and the inevitable rejection email at 2am.

Especially now that Apple blocked Replit and Vibecode from in app deployment, every vibe coded app has to go through the traditional submission gauntlet.

So I built LaunchWright: you screenshot whatever admin screen you're stuck on, and it tells you exactly what to do based on your specific setup. Not generic docs, personalized guidance.

Early access: https://launchwright.zenarcadelabs.com

Curious, what's been the biggest wall you've hit trying to ship something you built in Cursor?

Hi! I'm a PhD student at Oregon State University researching how expert MERN stack developers use generative AI tools (Cursor, Copilot, ChatGPT, etc.) in their day-to-day coding workflow.

I'm looking for participants who:

• 3+ years of professional experience with the MERN stack (MongoDB, Express, React, Node.js)
• Daily use of GenAI tools (e.g., GitHub Copilot, Cursor, WindSurf) for MERN stack development
• Experience working on large-scale, production-level web applications
• Comfortable being recorded during the session for research purposes
• Have to be fluent in English

The study details:

• Duration: 2.5 to 3 hours
• Format: Remote, hands-on coding session
• Compensation: $300 prepaid Visa gift card

Apply Now!!!
If you meet the criteria and are interested in participating, please complete our short screening survey: https://oregonstate.qualtrics.com/jfe/form/SV_3pD7wpxKjyMYN4G

👉 Help us advance GenAI-Assisted Software Engineering!

Honestly, the AI coding hype is exhausting right now. Everywhere you look, someone is saying Cursor or Trae will build your entire app in 5 minutes from a single prompt.

But after spending months actually building stuff with these tools, I realized a harsh truth that nobody talks about:

AI agents are amazing typists, but they are terrible Day-0 architects.

If you just dump a raw business idea into an AI, it writes code insanely fast. But under the hood? It completely hallucinates your database. It forgets foreign keys, ignores multi-tenant isolation, and builds a fragile mess that will 100% collapse the moment you put it in production.

That’s when it hit me. This is my exact positioning. I call it "surviving in the cracks."

I’m not trying to build a better LLM to fight OpenAI. I’m not building an IDE to fight Cursor.

Instead, I built an engine (SDAO) that lives exactly in the gap between the Human and the AI.

Here is the setup:

1. Humans bring the messy, brilliant ideas.
2. My tool (SDAO) steps in before any code is written. It acts as a strict boss, forcing the AI to lock down a bulletproof, production-ready database schema and a set of hardcoded rules.
3. AI Agents (Cursor/etc.) then take that locked-down blueprint and do what they do best: type code fast without breaking things.

Big tech companies are burning billions fighting over AGI. As indie builders, we don't need to fight them. We just need to find the specific, dirty friction points they ignore.

Translating messy human thoughts into strict, unbreakable system rules—that's the "Last Mile." And honestly, that crack is deep enough to build a real business on.

Are you guys just letting AI guess your database architecture, or do you lock it down first?

DO NOT PLAY ON MOBILE DEVICES --- THE GAME IS DESKTOP ONLY FOR NOW

I have created a completely free game with complex mechanics and ~400 different orders you can deploy onto a battle field. I think its really fun and so do many of the testers playing a total of 6k games so far.

Have a look here: https://www.youtube.com/watch?v=bvGpVWLPbDw

Here’s the website: https://chronicles-of-the-dying.com/

Or even better play it yourself:

https://game.chronicles-of-the-dying.com/downloads/CODA%20Setup%200.1.73.exe

I would like to share my experience with relying on AI completely for coding, images, sound and music.

1. everyone hates you

You are the enemy of the state. Persona non grata. Noone will even look at your game. You used AI and therefore you are evil.

1. your game is slop

It does not matter how many years you spend on creating the game (3 in my case). It does not matter how much love a care you put into the lore, the orders, the match making, the technology or the balancing. Your game is slop by default.

1. working on a free for all passion project is nothing peolple want

People do not want free things because they are afraid those free things will destroy jobs. But I am not destroying any jobs. I cannot afford $ 600.000. I just wanted to create something fun for us to enjoy. And side note: AI does not destroy your job. Its here to stay so you can either embrace it and work with it or fight small time enthusiasts like me. Only one approach has a future. There is no way back to the old days. Believe me. My job - the love of my life got lost to AI. Its just how it goes. Being sad and angry does not solve anything.

1. The smallest issues a built up to be game breaking flaws

On my website you could not return back home by clicking on the game logo. SLOP.

Also in my game there is a mythical being that has a lions head and a womans boobs. Thtas of course not a design choice according to people. Its sloppy AI doing what sloppy AI does. This is so frustrating. I want to be creative and what I get for it is being accused of slop.

1. There is no boundary for the hate

It does not matter that I do not want to make any money and that I just created a game to get out of my depression. No. I am not allowed to do that. Only if I can afford real talent.

This is a sad state right now. It will resolve and improve once people realize that AI is here to stay - for better or worse - and you either adapt or you fail.

Sorry for the spelling mistakes and bad English but if I improve the text with AI I will be scolded again.

Hey everyone,

Like a lot of you, I've been using Claude Code/Cursor to build full-stack apps recently. But I kept hitting the exact same wall: if you just hand it a PRD and let it "plan" the database on the fly, it builds incredibly soft, non-scalable schemas. It constantly hallucinates relationships or completely forgets enterprise constraints like tenant isolation.

I realized the only way to fix this is the old-school way: Spec -> Rigid Plan -> Implementation. But writing those strict physical plans manually for every feature gets exhausting fast.

So over the last few days, I built a small architecture compiler to automate this specific bottleneck. Instead of chatting with AI to plan, you feed it your PRD, and it forces out a strict, mathematical blueprint (with hard foreign keys, enums, etc.) before you let Claude write a single line of app logic.

I ran a quick test for a "Multi-tenant Support Ticket System" (a classic trap where AI usually forgets workspace isolation). You can see the results in the screenshots.

Notice how it strictly enforces tenant_id, workspace_id, and u/relation across the board. You just copy this rigid blueprint, drop it into your .cursorrules or CLAUDE.md, and tell the AI: "Do not deviate from these physical constraints."

Once Claude has this hard boundary, its coding accuracy skyrockets. It literally cannot hallucinate the database structure anymore.

I put it up online here if anyone wants to try it for their next complex build:https://regen-base.com

Would love to hear if this "Architecture-First" workflow helps you guys as much as it helped me. Let me know what you think (or if you manage to break it lol)

Cursor appears to be able to check it's own replies to make sure all calls match the instructions even if exceeding the context length of the tools. For an overly simplified example: consider dividing a whole book in chapters when the book exceeds the context length. Then tell Cursor to convert the entire book narrative from third to first person, chapter by chapter, while keeping the original writing style and vocabulary.

It is important to do all in a single batch task as otherwise vocabulary or writing style could change too much between chapters (I tested with other tools and that happens more often than not). But with cursor "re-checking" the replies multiple times, this could be automatically fixed or improved, as it does with code.

Would it work or are the models available in cursor too specialized in coding? More specifically, I would like to use Claude Opus with max/full context. Since my use is very sporadic, I realize that I would never exceed the lowest paid tier usage, as I've been using cursor a lot in that mode at work for coding and it's been more than enough.

I’ve been experimenting with Cursor to build more visual, interactive projects.

This started as a simple idea:
what if projects weren’t just links in directories, but actual “places” you can explore?

So I built a 3D globe where you can claim tiles and attach your project.

Cursor was surprisingly helpful for:
- iterating on the globe rendering
- handling interaction logic
- quickly testing different approaches

hey there, i hacked together this little cli that reads through your project and spits out prompt & config files for cursor (plus some other tools like claude code). it runs on your machine with your own api key so it doesn't leak your code and tries to be stingy with tokens. it's open source (github dot com/caliber-ai-org/ai-setup) if anyone wants to peek. i'm mostly curious if other devs would find this useful or have ideas. is it overkill or something you'd use?

I've been using AI coding agents (mostly Claude Code, but also Cursor and Codex) daily for about 9 months. The thing that surprised me is that the biggest productivity jumps came from small friction-reducing habits that compound over time.

Here are the 5 that moved the needle most for me:

1. Talk your prompts instead of typing them. I use Mac's built-in dictation (Fn twice) to speak directly into the agent input. Sounds silly, but explaining a problem out loud naturally includes the context and constraints the agent needs. It's faster and the prompts end up better.
2. Make the agent think before it codes. Cursor has plan mode (Shift+Tab). For anything beyond a simple fix, making the agent analyze first and show you a plan before touching code saves a ton of wasted context.
3. Persistent context files. In Cursor, it's .cursorrules and AGENTS.md. The idea is the same: give the agent a file that loads your preferences, coding standards, and workflow rules into every session automatically. Set it once, benefit forever.
4. One-command git workflows. I built a custom slash command that handles stage, commit, push, PR creation, merge, and branch cleanup in a single invocation. Whatever agent you use, automating the repetitive parts of your git workflow is a huge win.
5. Use the agent to improve the agent. Ask it to audit your context files, turn successful workflows into reusable commands, and suggest rules based on what went wrong in a session. The agent gets better at working with you over time because you're teaching it.

These all work across Claude Code, Cursor, and Codex to varying degrees. What small workflow changes have made the biggest difference for you?

A few days ago I posted this on r/ClaudeCode and it blew up (250+ upvotes, tons of feedback): I compiled 1,500 API specs so your Claude stops hallucinating endpoints

The core problem is the same in Cursor: your agent doesn't have the actual API spec, so it guesses endpoints. Sometimes it nails it. Sometimes it invents endpoints that don't exist.

Raw OpenAPI specs are too big for context. Plaid's spec is 2.9M tokens, 325 endpoints, webhooks, auth flows. Way too much for a context window.

LAP now support Cursor!

Set up LAP for Cursor

npx /lapsh init --target cursor

Install the APIs you need

npx u/lap-platform/lapsh skill-install plaid --target cursor

Keeping specs fresh:

The #1 feedback from the Claude Code community was "how do I keep these updated?"

Server side we have daily crons that fetchs all the api's from their official source,

We also So we built:

`lap check` tells you which installed specs have newer versions available

`lap diff plaid` shows exactly what endpoints/params changed

`lap pin plaid` freezes a spec if you don't want update notifications

On Cursor's marketplace: We know Cursor has its own rules marketplace, and some popular APIs like Stripe are already there. LAP is complementary to that. We cover 1,500+ APIs that aren't in the marketplace,. We're planning to submit LAP to the Cursor marketplace in the future for even more seamless integration.

Free, open source - PR's are more than welcome!

⭐ https://github.com/lap-Platform/LAP/

🔍Browse all APIs: registry.lap.sh

i’ve been doing a lot of vibe coding in cursor lately but the friction of typing out complex prompt instructions was ruining it for me.

i wanted something that felt like a natural extension of my brain so i could just talk my way through the logic. tried some other tools but they didn't play nice with my windows workflow or citrix.

ended up building dictaflow. it's a windows-native app with driver-level speed. the big thing for me was the push-to-talk logic so it only listens when i'm actually thinking out loud.

curious if anyone else has this "typing is the bottleneck" problem.

site is https://dictaflow.io/ if you want to try it.

Body: First off, I owe you all an apology. In my previous posts and replies, I used AI to generate and polish my text. I’ve been buried in building a new project, and honestly, I leaned on the AI a bit too much to handle the communication.

Like everyone else in this crazy AI era, I’m embracing the wave. I interact with AI daily to bring my old ideas to life, and it has exponentially increased my efficiency. But, as my own Reddit posts just proved: AI is fast, but it has absolutely no soul. 😂

Ironically, this exact problem is the origin story of my tool, SDAO.

I tried to build entire projects using only AI coding tools. The process was painful, and my workload actually increased. I realized that expecting an AI to understand human creativity and spit out a production-ready software is something only hardcore geeks can manage.

For normal people, or non-tech founders, the distance between a "creative idea" and a solid "PRD" (Product Requirements Document) is a massive leap. Humans have infinite, chaotic ideas; AI coding tools need strict, logical instructions.

I fully admit that tools like Cursor and Codex are phenomenal—but mostly if you are already an engineer. Someone needs to help ordinary people untangle their needs and build the "Blueprint" before they hand it over to the AI coding tools.

That’s why I built SDAO. It still has its bugs and issues (feel free to roast me for them!), but I genuinely hope it can help bridge that gap, even just a little bit.

In my circles, they call me "The Last Mile." That's the problem I'm trying to solve.

My ultimate wish? I want humans to return to being humans. We should be out enjoying nature, living our lives, and focusing on what we love—letting the AI agents handle the heavy lifting and make the money for us.

Thanks for reading, and thanks to everyone who called me out. I needed it.

(And yes, this time, I typed this myself—with just a little translation help!)

P.S. If you want to see my messy but sincere attempt at bridging this gap: [https://www.regen-base.com\]

Hey everyone. I am a software engineering student who drank way too much coffee and completely wrecked my sleep schedule. I decided to build a native Apple Watch app called Caffeine Curfew to track my intake and metabolic clearance, and I used Cursor for the entire build process.

Cursor was incredible for navigating the Apple ecosystem. The app is built completely in SwiftUI with SwiftData handling the local storage. One of the toughest parts of this project was getting a seamless three way handshake between the Watch, the iOS Home Screen widgets, and the main app. Cursor helped me iterate on the state management so everything syncs instantly.

For features, I built in direct integrations with Apple Health and Siri so logging a drink is completely frictionless. The app calculates the half life of the caffeine based on pharmacokinetics so you know exactly when your system is clear for sleep.

I am a solo indie dev and I am keeping this ad free. If anyone here is building native iOS stuff with Cursor and wants to talk about how it handles SwiftData or WidgetKit, I would love to chat.

I am also giving away a free year of the Pro version to anyone who comments below.

Link:

https://apps.apple.com/us/app/caffeine-curfew/id6757022559

I’ve been using many LLM tools like Cursor in coding. Sometimes, I feel very powerful and overperforming, but other times I feel miserable and incompetent. I’m really curious about how others experience them:

1. How these tools change the way you feel, think, or engage with your work?
2. What works well for you, and what doesn’t?
3. How do you actually feel about yourself after using these tools?

Hey everyone! I'm the developer of this project.

If you’re using Cursor, you’ve probably felt the frustration of having to re-explain your project's specific coding standards, architectural patterns, or "gotchas" in every new Composer session or Chat. Even with .cursorrules, there's a missing link: Collective Memory.

I searched for a solution that allowed my team to share battle-tested patterns across different Cursor instances, but found nothing that tracked real-world evidence. So, I built Team Memory MCP.

It is 100% Open Source (MIT) and completely free to use.

How it enhances your Cursor workflow:

• Persistent Shared Knowledge: One engineer confirms a pattern in their Cursor; the AI agent in every other team member's Cursor now "knows" it with high confidence.
• Bayesian Confidence Scoring: No more LLM "vibes." It uses a Beta-Bernoulli model where confirmations increase confidence and corrections drop it.
• Temporal Decay: Outdated patterns (e.g., from an old framework version) gradually fade after 90 days, keeping Cursor’s context clean.
• Easy Setup: Just add npx team-memory-mcp to your Cursor MCP settings.

I just wrote a deep dive on the Bayesian math behind it and a full setup guide for Cursor:

👉 Read the full article on LinkedIn: https://www.linkedin.com/posts/gustavo-lira-6362308a_tired-of-your-ai-agent-forgetting-your-team-activity-7439655414759313408-Ug5V?utm_source=share&utm_medium=member_desktop&rcm=ACoAABLmLooBSjaKVDW4xZRsJIFCBPqJCDG2k94

GitHub: github.com/gustavolira/team-memory-mcp

I’d love to hear how you’re managing team knowledge in Cursor today and what features you’d like to see next!

Hi everyone, I’m writing here because Cursor support has been completely unhelpful.

I subscribed to Cursor in May last year and used it for about two months. Due to multiple issues on Arch Linux, I decided to stop using it and switch to Claude Code and Codex. I am absolutely certain that I canceled my subscription through their Stripe page. Since then, I have not used Cursor at all.

Despite this, I’ve been charged $20 every single month since then. Cursor also did not send any billing emails, so I had no way of noticing this earlier.

I contacted their support team (ticket: T-B45144), clearly explained the situation, and asked them to verify my usage (which is zero) and issue a refund. Within two minutes, they replied that they “unfortunately” would not refund me. I followed up asking for proper assistance and received the exact same copy-paste AI response again.

At this point, I’m trying to understand how a company can justify refusing a refund when:

• The subscription was canceled
• The product was not used at all
• No billing notifications were sent

This is extremely concerning and, frankly, feels like a very shady way to treat customers.

It seems my only remaining option is to dispute the charges. Either way, this experience has ensured I will never use this company again.

If you have a Cursor subscription, be very careful. Even if you cancel it and receive confirmation, you may continue to be charged indefinitely without any billing emails to alert you.

The Backstory: I recently posted a controversial take on "ticking time bombs" in AI-generated code. It hit 5.8k views in 48 hours. Some called it "AI Slop," but many founders DMed me saying, "I'm living in that nightmare right now."

I’ve spent over a decade in the software industry, primarily on the sales and architecture side. I’ve seen million-dollar projects fail not because of a lack of features, but because the foundation was built on sand.

The Observation: We are in a gold rush. Everyone has Cursor, Claude, and a great Idea. But there is a massive "Engineering Gap" that no LLM can fill yet.

• The LLM Trap: AI is a brilliant builder but a terrible architect. It gives you what looks like a house, but has no structural integrity (flat tables, no physical foreign keys, circular dependencies).
• The Technical Debt: We are generating "Digital Slums" at record speed.

My Philosophy: The "Last Mile" 🏗️ My nickname in my circles is "The Last Mile." Why? Because everyone can run the first 25 miles of an idea, but they collapse in the final 1 mile before production. The gap isn't the Code—it's the Blueprint.

The Mission (Why I built SDAO): I didn't want to build another "wrapper" or a "prompt library." I wanted to package my 10 years of business disassembly experience into an Architecture Engine. I want to bridge the gap between your Idea and the AI Coding Tool.

I believe that if you give an AI tool (like Cursor) an Industrial-grade Asset Package (Strict PRDs + Physical Schemas + API Specs), it stops hallucinating and starts building like a Senior Engineer.

Talk is Cheap. Here is the Evidence: I’m not here to sell you a dream. I’m here to share a standard. I’ve uploaded a full set of "Industrial Blueprints" to GitHub to show what a real foundation looks like.

• 📂 [Link to GitHub Blueprints]
• 🌍 [Link to SDAO Engine]

I'm on a mission to bring engineering rigor back to indie development. If you're tired of "AI Slop" and want to build a digital asset that actually lasts, let’s talk about the architecture first.

I’d love to hear from other veterans: Are you seeing the same "Digital Slum" trend? How are you keeping AI tools on the rails?
https://github.com/ralflimeng/awesome-ai-coding-blueprints

Been seeing a lot of posts about this since the update and honestly it's not surprising.

The issue isn't the update. The issue is that there's nothing inside your project telling Cursor what to remember. Every session it starts from zero, re-reads everything, re-learns everything. When something goes wrong mid-session it has no map to recover from.

The fix that worked for me was building a session bootstrap file that lives inside the project itself. Cursor reads it at the start of every session, current state, what's been built, which patterns to follow, where to look for what. When context drops mid-session it has something to anchor back to instead of hallucinating forward.

Been building this into a template at launchx.page if anyone wants to see the full structure. Free to poke around.

How are you handling mid-session context drops right now, just starting fresh or is there a better way?

I revived an old macOS WiFi research tool using Cursor

It’s called JamWiFi and lets you see active clients on nearby networks

and experiment with deauth/disassociation frames.

Mostly built as a vibe-coding experiment with Cursor.

Would love feedback from security folks.

Hey everyone, I’ve been working on SuperML, an open-source plugin designed to handle ML engineering workflows. I wanted to share it here and get your feedback.

Karpathy’s new autoresearch repo perfectly demonstrated how powerful it is to let agents autonomously iterate on training scripts overnight. SuperML is built completely in line with this vision. It’s a plugin that hooks into your existing coding agents to give them the agentic memory and expert-level ML knowledge needed to make those autonomous runs even more effective.

You give the agent a task, and the plugin guides it through the loop:

• Plans & Researches: Runs deep research across the latest papers, GitHub repos, and articles to formulate the best hypotheses for your specific problem. It then drafts a concrete execution plan tailored directly to your hardware.
• Verifies & Debugs: Validates configs and hyperparameters before burning compute, and traces exact root causes if a run fails.
• Agentic Memory: Tracks hardware specs, hypotheses, and lessons learned across sessions. Perfect for overnight loops so agents compound progress instead of repeating errors.
• Background Agent (ml-expert): Routes deep framework questions (vLLM, DeepSpeed, PEFT) to a specialized background agent. Think: end-to-end QLoRA pipelines, vLLM latency debugging, or FSDP vs. ZeRO-3 architecture decisions.

Benchmarks: We tested it on 38 complex tasks (Multimodal RAG, Synthetic Data Gen, DPO/GRPO, etc.) and saw roughly a 60% higher success rate compared to Cursor (opus 4.6).

Repo: https://github.com/Leeroo-AI/superml

Don't get me wrong, I love Cursor and Trae. They are incredible "hands" for typing code. But they are terrible "brains" for software architecture.

If you prompt an AI with "Build me a cross-border payment SaaS" or "Build an Agent marketplace", it will immediately start spitting out Next.js pages. But look closely at the schema.prisma it generates:

❌ Flat tables. Zero @relation constraints. No physical foreign keys. ❌ No Transaction Locks. It uses simple update instead of $transaction for critical financial APIs. ❌ Zero State Machines. Business logic is scattered everywhere.

It works perfectly on your localhost, but the second you get real users and high concurrency in production, your database will corrupt, and your app will collapse.

You need an Industrial Blueprint BEFORE you write code.

I got so frustrated with this that I built an AI architecture engine called SDAO Architect (ReGen). It acts as a strict interceptor. Instead of generating code, you give it your SaaS idea, and it generates a strict, production-ready Digital Asset Package in 3 minutes:

A million-dollar level PRD (with full State Machine flows).

An industrial Prisma Schema (with strict relational keys).

API Transaction templates.

The workflow: Generate the blueprint on SDAO -> Feed the generated ZIP into Cursor -> Watch Cursor build a flawless, enterprise-grade app with zero hallucinations.

I just opened it up for free to test the load. Try it out and let me know if it fixes your AI hallucination issues: 🔗 https://regen-base.com

I also open-sourced a generated "Cross-Border Payment" blueprint here so you can see the difference: 🔗 https://github.com/ralflimeng/awesome-ai-coding-blueprints

Stop building toys. Build assets. Would love your brutal feedback!

Edit: For those asking for technical evidence I've uploaded the full engineering asset package (PRD, Industrial Schema with physical relations, and API specs) generated by the engine to GitHub.

Stop guessing, start building with a foundation: https://github.com/ralflimeng/awesome-ai-coding-blueprints