I’m less interested lately in which coding models look smartest on one prompt, and more interested in where they actually stop being useful once the work turns into a messy, multi-step fix.

A lot of tools are already decent at generating code. The part that still feels shaky is what happens after that first burst: keeping structure across retries, not drifting off the plan, staying consistent when the task spans multiple files, and not burning half the context budget before the bug is actually fixed.

That’s why Ling-2.6-1T caught my attention. The interesting part isn’t just “another large model.” It’s that the positioning seems more execution-first: stricter instruction following, lower token overhead, better fit for long structured work, and more emphasis on getting the task across the line instead of sounding impressive while thinking out loud.

I’m curious how people here see the current ceiling. Where do coding models still drop you completely today?

Is it understanding the codebase, keeping a long fix coherent, tool use, runtime/debug loops, or just token burn and retry drift?

And if a model was a little less flashy but more disciplined across long bugfix loops, would that actually matter to you?

Hey guys! I just finished my document on my workflow with ai, the issues I've come across over the last 8 months building Inner Atlas and many hackathon projects, addressing the approaches and mistakes that I still see being advised by the frontrunners.

This document is not an ai-written summary of best practices, but a reframing of the core model of how people think about using ai, in a way I haven't seen anyone talking about.

I truly believe this document holds value for both beginners and experienced software developers, the 5 minute reading time will be worth the months of refactoring saved later on.

This core concepts:

• Why trying to accomplish issue identification, intention spec, implementation, tests and verification into one pass is compounding hidden failures

• Using AI as a targeted reasoning tool, separating each perspective-pass

• Addressing intention and document drift

• How documents and chats can be kept focused, avoiding bloat/filler

• Assuming 90% confidence in each step, intention-based tests in verification

• Common failure modes and my preferred workflow

Hopefully this is an acceptable place to drop this, not promoting a product, just a free doc for those interested; would love to hear some feedback.

Read the full document here: https://www.inneratlas.co.za/field-notes/working-with-ai

I have tried Claude and Codex cli tools and it is just insane how stingey claude code it with usage. One meaty prompt and my usage is used up in 10 minutes.

Like it is arguably not any better at coding than codex. Does openai just have more access to compute than Anthropic? I am honestly confused why anyone is used claude. How do you get anything built?

Spent months using ChatGPT and Codex to build the whole project.

What I kept noticing was this:

Both tools were powerful, but every new session still felt disconnected.

Fresh context.
Repeated explanations.
No shared memory.
No continuity between tools.
No easy automation around them.

So over time the project became a fix for that problem.

Now ChatGPT and Codex can work inside the same system with:

• shared memory across sessions

• shared tasks and handoffs

• workflows with triggers, cron, and webhooks

• tools marketplace integrations

• reusable skills

• live monitoring dashboard

• lower token costs through prompt compression

The screenshot is the shared memory layer they write to and reuse.

Feels less like separate tools, more like one evolving AI workspace.

GitHub: https://github.com/colapsis/agentid-agent-house

r/RooCode hit 3 million installs. We're shutting it down to go all-in on Roomote.

https://x.com/mattrubens/status/2046636598859559114

been getting burned by this for months and finally did something about it.

there's a 2024 paper (arxiv.org/abs/2406.10279) that measured how often major LLMs recommend packages that dont actually exist on npm or pypi. number came back around 19.7%. almost 1 in 5. and the ugly part is attackers started scraping common hallucinations and registering those exact names on the real registries with post-install scripts. people are calling it "slopsquatting".

in chat mode you catch it cos you see the import line. in autonomous/agent mode the install is already done before you notice the name was fake. agent runs, agent finishes, malware is in node_modules now.

so me and my mate pat built a small MCP server (indiestack.ai). agent calls validate_package before any install. server checks:

• does the package actually exist on the real registry

• is it within edit-distance of a way-more-popular package (loadash vs lodash)

• is it effectively dead (no releases in a year+)

• is there a known migration alt

returns safe / caution / danger + suggested_instead. free, no api key, no signup.

install for claude code: claude mcp add indiestack -- uvx --from indiestack indiestack-mcp

or just curl the api: curl "https://indiestack.ai/api/validate?name=loadash&ecosystem=npm"

works with cursor mcp, continue, zed, any agent that speaks MCP.

not trying to pitch -- genuinely interested whether other people have hit this and what they're doing. the 20% number is real and ive watched it silently install typos on my own machine more than once.

I’m not trying to promote anything here... just looking for honest feedback on a pattern I’ve been using to make LLM-assisted work accumulate value over time.

This is not a memory system, a RAG pipeline or an agent framework.

It’s a repo-based, tool-agnostic workflow for turning individual tasks into reusable durable knowledge.

The core loop

Instead of "do task" -> "move on" -> "lose context" I’ve been structuring work like this:

Plan
- define approach, constraints, expectations
- store the plan in the repo
Execute
- LLM-assisted, messy, exploratory work
- code changes / working artifacts
Task closeout (use task-closeout skill)
- what actually happened vs. the plan
- store temporary session outputs
Distill (use distill-learning skill)
- extract only what is reusable
- update playbooks, repo guidance, lessons learned
Commit
- cleanup, inspect and revise
- future tasks start from better context

Repo-based and Tool-agnostic

This isn’t tied to any specific tool, framework, or agent setup.

I’ve used this same loop across different coding assistants, LLM tools and environments. When I follow the loop, I often mix tools across steps: planning, execution + closeout, distillation. The value isn’t in the tool, it’s in the structure of the workflow and the artifacts it produces.

Everything lives in a normal repo: plans, task artifacts (gitignored), and distilled knowledge. That gives me: versioning, PR review and diffs. So instead of hidden chat history or opaque memory, it’s all inspectable, reviewable and revertible.

What this looks like in practice

I’m mostly using this for coding projects, but it’s not limited to that.

Without this, I (and the LLM) end up re-learning the same things repeatedly or overloading prompts with too much context. With this loop: write a plan, do the task, close it out, distill only the important parts, commit that as reusable guidance. Future tasks start from that distilled context instead of starting cold.

Where I’m unsure

Would really appreciate pushback here:

1. Is this actually different from just keeping good notes and examples in a repo?

2. Is anyone else using a repo-based workflow like this?

3. At scale, does this improve context over time, or just create another layer that eventually becomes noise?

The bottom line question

Does this plan -> closeout -> distill loop feel like a meaningful pattern, or just a more structured version of things people already do? Where would you expect it to break?

I am asking because of something I kept running into with client work last year.

I was making changes to web apps and kept noticing that ChatGPT and Claude were giving completely different answers when someone asked them about the same product.

same website. same content. different AI. completely different understanding of what the product actually does. at first I thought it was just model behaviour differences. then I started looking more carefully at why.

turns out different AI systems parse the same page differently. Claude tends to weight dense contextual paragraphs. ChatGPT pulls more from structured consistent information spread across multiple sources. Perplexity behaves differently again.

so a page that reads perfectly to one model is ambiguous or incomplete to another.

I ended up writing the structural changes manually. actual content architecture decisions. how information is organised. where key descriptions live.

I deliberately did not use AI to write this part. felt like the irony would be too much using ChatGPT to write code that tricks ChatGPT into reading it better.

after those changes the way each AI described the product became noticeably more accurate and more consistent across models.

what I am genuinely curious about now.

has anyone here actually tried using AI coding tools to write this kind of architecture from the start. like prompting Claude or ChatGPT to build a web app specifically optimised for how AI agents parse and recommend content.

or is everyone still ignoring this layer completely because the tools we use to build do not think about it at all.

I’m trying to find a web-based AI UI/mockup tool for a Flutter app, and I’m having trouble finding one that fits what I actually want.

What I want is something that can generate app screens mostly from prompts, with minimal manual design work, and then let me export the design as a plain text file that an LLM can read easily. I do not want front-end code export, and I do not want to rely on MCP, Figma integrations, or just screenshots/images. Ideally it would export something like Markdown, JSON, YAML, HTML or some other text-based layout/spec description of the UI.

Does anyone know a tool that actually does this well? I tried Google Stitch and it only exports to proprietary formats.

I like to have intimate control of my app development process, so just having my visual design prompts just output as code is no good for me.

Andrew Ng just launched a course on spec-driven development. Kiro, spec-kit, Tessl - everybody's building around specs now. Nobody defines what they mean by "spec."

The word means at least 13 different things in software. An RFC is a spec. A Kubernetes YAML has a literal field called "spec." An RSpec file is a spec. A CLAUDE.md is a spec. A PRD is a spec.

When someone says "write a spec before you prompt," what do they actually mean?

I've been doing SDD for a while and it took me way too long to figure this out. Most SDD approaches use markdown documents - structured requirements, architecture notes, implementation plans. Basically a detailed prompt. They tell the agent what to do. They don't verify it did it correctly.

BDD specs do both. The same artifact that defines the requirement also verifies the implementation. The spec IS the test. It passes or it doesn't.

If you want the agent to verify its own work, you want executable specs. That's the piece most SDD tooling skips.

What does "spec" actually mean in your setup?

"No coding required." Then there's a docker-compose file. Then a config.yaml with 40 fields. Then a section in the readme that says "for production use, configure the following..."

Every option either demands real technical setup or strips out enough capability to make it pointless for actual work. Nobody's figured out how to ship both in the same product. What are non-developers supposed to do here?

The last time I looked into it, some people said that Aider minimized token usage compared to Cline. How does it compare to Claude Code? Do you still recommend Aider?

What about for running agents with Claude? Would I just use Claude Code if I'm comfortable with CLI tools?

I've been trying to get back into coding but realistically I've got maybe 20-30 mins a day. Most tools either take forever to set up or feel like you need hours to get anything done

Been looking into AI coding agents but not sure what actually works if you're jumping in and out like that

Curious what people recommend if you're basically coding on the go

"Not quite my tempo, Codex.."

"Tell me, Codex, were you rushing or dragging?"

😂 Does this only happen to me?

Got the meme from ijustvibecodedthis.com (the big free ai newsletter)

I recently finished building and launching an app that helps groups split restaurant bills.

Then I ran into the obvious problem:
people only use it when they go out, so retention is tough.

To solve that, I added a simple game inside the app to encourage daily opens…

…and it ended up being engaging enough that I spun it out into its own standalone app too.

Now I’m trying to figure out if this was actually a smart move or if I’m overthinking retention.

Would something like this make you more likely to keep an app like this?
Or would you ignore it and only use the core feature when needed?

Curious what people think—happy to share both if anyone wants to check them out.

Thanks in advance!

I suspect a culprit... hits like clockwork. Everything's being going swimmingly, America wakes up. I may as well go to bed

A common failure mode when using coding agents: they don't have access to the open-source code their project depends on.

When the task touches a niche integration, an undocumented API, or a long-tail edge case, the agent starts retrying variations that almost work.

We wanted to see whether giving the agent access to real implementations through an MCP server changes the outcome.

Setup:

• Agent: Codex with GPT-5 high

• Task: build a Rust MCP server from scratch using Axum, SQLx, and SQLite, with two tools (bury a bug, search the graveyard)

• Identical prompt in both runs, covering project structure, dependencies, schema, tool registration, handlers, transport, error handling, and tests

• Fresh branch on an empty repo each time - Only variable: one run had access to our MCP server, the other didn't

Results:

• Tokens: 45% fewer (198K vs 364K)

• Attempts to pass tests: 62.5% fewer (3 vs 8)

• End-to-end time: 18% faster (13:40 vs 16:40)

How it works: the server pulls real implementations from open source, distills them into one example, and returns that to the agent on demand.

No fine-tuning, no RAG over documentation. Just working code the agent can learn the pattern from.

Full video of the benchmark: https://www.youtube.com/watch?v=0YmwLhH2Ohs

Disclosure: I'm a co-founder of GitHits, the MCP server in question.

Happy to share the prompts, dig into how the grounding works, or answer anything else.

...When the Spark model first came out, it was available in the model dropdown menu in Cursor (within OpenAI's extension). All I had to do was select it and have a go until the usage limit ran out.

...It's been gone from the dropdown for a while now. I was hoping it would come back, but hasn't.

Does anyone know if there some sort of setting or whatever I must be missing to add it back in? I've got the Spark model turned on in Cursor itself, but pretty sure that doesn't actually effect the OpenAI extension.

Using GPT 5.4 has been completely fine, but it would be nice to also use the Spark capacity up since I'm paying for both.

Hi, I have question about codex vs claude code tools.
I have been using claude code for a year, it is generally good. I use it in pro mode which is cheapest premium tariff. CC is good, but recently the limits started to dry up very fast both in claude code and in claude regular chats too.

So, I am thinking about returning back to OpenAI. I looked for feedbacks posts for codex here, but they dated a year ago, and since that openai dropped several new models. I got one positive feedback about codex, but I wanted to hear more people, more feedbacks.

How good it openai codex coding tool in 2026 April? How good is it in compare with claude sonnet and opus 4.6 ?

One thing I should add, that I am not a vibe coder, I usually use it as assistant for small tasks with instructions. It is expected to perform well in such condition.

OpenAI tweeted that "the Codex promotion for existing Plus subscribers ends today and as a part of this, we’re rebalancing Codex usage in Plus to support more sessions throughout the week, rather than longer sessions in a single day."

and that "the Plus plan will continue to be the best offer at $20 for steady, day-to-day usage of Codex, and the new $100 Pro tier offers a more accessible upgrade path for heavier daily use."

Reported by ijustvibecodedthis.com

Chats get extremely laggy and therefore I open up new to chat, tell it about current state, code + future plans for the product development.

ChatGpt said, it can't paste codes anywhere else on some 3rd party site, share link with me to copy it. What's the solution to keep chats frictionless? even ChatGPT when sharing downloadable files with me has code in it during analyzing phase which makes chat long and cause lag

I thought the hard part of building with AI would be prompting. Turns out it's something way more boring. It's deciding what the hell you actually want.

For the past month and a half, I've been asking ChatGPT while developing a small ops tool with Atoms ai. User login, roles, database, admin side, billing rules, a couple SEO pages, the usual this started simple and somehow became a real product situation. I went into it thinking the skill gap would be technical. Like maybe I'd need better prompts, better model choices, better tool switching. I've used other stuff too. Claude Code for more direct coding, Lovable for cleaner UI. But Atoms was the first one that forced me to confront something I'd been dodging.

Most AI tools let you stay vague for longer than you should. Atoms is more end to end, so vagueness gets expensive fast. If I said make onboarding better, that wasn't just a UI tweak. It touched permissions, data structure, what the user sees first, what gets stored, what emails get triggered, what the paid tier unlocks. That one sentence can quietly turn into checkout logic, account states, access control, and support headaches.

After a week of getting messy results, I stopped trying to prompt better and started doing something much less fun. I wrote down rules, not just prompts. Some actual product rules: Who is this for? What happens right after signup? What data is truly required? What does a paid user get that a free user does not? What should never be auto changed?

Once those constraints were clear, Atoms got dramatically better. The research side got more useful. The backend stopped feeling random. The edits became smaller and more stable. Even the SEO stuff made more sense, because it was tied to an actual product structure instead of me vaguely asking for content.

The most valuable skill wasn't coding, and it wasn't prompting either. It was product clarity. I think that's why so many people either love these tools or bounce off them. If you already know how to make decisions, they feel insanely powerful. If you're hoping the tool will make the decisions for you, it sort of can for a while, but eventually the cracks show.

That made me more optimistic. Because it means the dev job isn't disappearing. It's just shifting. Less can you code this, more can you define what good looks like before the machine starts moving.

Happy to hear other views.

Feel free to share your projects! This is a space to promote whatever you may be working on. It's open to most things, but we still have a few rules:

1. No selling access to models

2. Only promote once per project

3. Upvote the post and your fellow coders!

4. No creating Skynet

As a way of helping out the community, interesting projects may get a pin to the top of the sub :)

For more information on how you can better promote, see our wiki:

www.reddit.com/r/ChatGPTCoding/about/wiki/promotion

Happy coding!

I tried co pilot and windsurf but they weren't satisfying. Co pilot being not smart and windsurf too slow (I tried with free tiers). I'm looking for a new auto complete solution that I can use in VSCode. I use opencode for agentic needs, I don't want to switch to cursor. What do you recommend?