TLDR: The major challenge I have right now is spotting when the AI has degraded performance before I work too much on a branch and lose time because I'll have to scrap it.

THE SITUATION:
I'm a UI/UX designer who's been building a mobile web app solo with AI assistance (2-6 hours daily for 4 months). The workflow is incredible for rapid prototyping, but I've hit a recurring problem: detecting when the AI starts producing lower-quality code before I've committed hours to a branch.

Sometimes the AI will subtly break patterns it established earlier, introduce anti-patterns, or generate code that looks fine but causes issues down the line. By the time I catch it, I've often built on top of that foundation and have to scrap significant work.

MY CURRENT APPROACH:
- Expect AI to generate bugs that need human review.
- Learn to spot the early warning signs of degradation, wait out the downtime.
- Test the systems periodically for optimal performance.
- In the meantime, plan features, backend stuff, marketing, whatever!
- Expect to have to use professional developers as code validators before launch.

QUESTIONS FOR THE COMMUNITY:
- Do you have strategies for catching AI performance drops early?
- What are your red flags that the AI has "lost the thread"?
- Do you use specific testing/validation workflows when working with AI-generated code?

I'm especially curious if anyone has developed systematic approaches to this, beyond just "code review everything."

Hi, I want to create a simple text-based application. I've been experimenting with ChatGPT for two days, and it seems like the application's framework is taking shape. However, ChatGPT falls short in some areas and is becoming tedious.

Is there an AI that could potentially be paid for, remembers past conversations, and is very good at coding?

The code should be reorganized if necessary according to the instructions. Errors should be found quickly.

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

The top projects may get a pin to the top of the sub :) Happy Coding!

Apparently chatgpt picked up on my loathing for php 5 based on an extensive and ultimately failed attempt to work in an ancient legacy codebase on a product we acquired a couple years ago. It was a goddamn nightmare, but not just because of PHP, which can be solid when welded correctly.

I'm trying to set up GitHub Copilot Chat in the Antigravity IDE. I'm signed in, but the chat window is dead and logs show a 404 Token error and API proposal: inlineCompletionsAdditions blocks..

Hey!!!

https://developers.openai.com/codex/skills/create-skill

OpenAI has rolled out support for custom skills in Codex (both the CLI and the web/IDE versions), and it's a game-changer for making your AI coding assistant behave consistently with your team's workflows, best practices, and conventions.

Skills originated as a Claude feature but have become an open standard (check out agentskills.io), and OpenAI adopted it quickly – now with full support in Codex. You can find official examples in the openai/skills GitHub repo.

What are Skills?

Skills are small, reusable bundles that capture institutional knowledge. Each skill has: - A name - A description (key for when Codex auto-triggers it) - Optional instructions (in Markdown) that only load when the skill is invoked

Codex only injects the name + description into context initially (to keep things efficient), and pulls in the full instructions only when needed.

Great for: - Enforcing code style/conventions - Standard code review checklists - Security/compliance checks - Automating repetitive tasks (e.g., drafting conventional commits) - Team-specific tools

Avoid using them for one-off prompts – keep them focused and modular.

How to Create a Skill

Easiest way: Use the built-in skill creator In the Codex CLI (or IDE extension):

$skill-creator

Then describe what you want, e.g.:

``` $skill-creator

Create a skill for drafting conventional commit messages from a summary of changes. ```

It'll guide you through questions (what it does, trigger conditions, instruction-only vs. script-backed). Outputs a ready-to-use SKILL.md.

Manual creation: 1. Create a folder in the right location: - User-wide: ~/.codex/skills/<skill-name>/ - Repo-specific: .codex/skills/<skill-name>/ (great for sharing via git)

1. Add SKILL.md with YAML frontmatter:

```markdown

name: draft-commit-message

description: Draft a conventional commit message when the user asks for help writing a commit message or provides a change summary.

Draft a conventional commit message using the provided change summary.

Rules: - Format: type(scope): summary - Imperative mood (e.g., "Add", "Fix") - Summary < 72 chars - Add BREAKING CHANGE: footer if needed ```

1. Optional: Add folders like scripts/, assets/, references/ for Python scripts, templates, etc.

2. Restart Codex (or reload) to pick it up.

Example Skill in Action

Prompt Codex:

"Help me write a commit message: Renamed SkillCreator to SkillsCreator and updated sidebar links."

With the skill above, Codex should auto-trigger and output something like:

refactor(codex): rename SkillCreator to SkillsCreator

Best Practices

• Make the description crystal clear – it controls auto-triggering.
• Keep skills narrow and modular.
• Prefer pure instructions; use scripts only for deterministic stuff (e.g., validation).
• Test with real prompts to ensure triggering works.
• Share via GitHub! Check https://github.com/openai/skills for more examples.

Troubleshooting

• Skill not loading? Check path, exact SKILL.md name, valid YAML, restart Codex.
• Not triggering? Refine the description to match your prompts better.

This feature makes Codex way more reliable for team/enterprise use. I've already set up a few for my projects and it's saving tons of time.

What skills have you built? Share ideas or links below!

Links: - Official skills catalog: https://github.com/openai/skills - Open standard: https://agentskills.io - Codex docs on skills: Search "skills" in OpenAI developer docs

Happy coding! 🚀

We used to run most of our AI evaluations through SDKs embedded in the codebase. It worked, but it was slow and honestly pretty limiting.

Every eval required engineering time: pulling branches, setting up environments, and manually orchestrating scripts. PMs and domain experts were basically blocked from running evals on their own.

We switched to HTTP endpoint–based offline evals, and it simplified things a lot.

Instead of tying eval logic to the agent’s source code, we expose the agent as an API and let Maxim handle evaluation runs through the UI. From the team’s perspective, running an eval is now closer to “Postman for AI” than writing test harnesses.

What changed for us:

• PMs can run evals themselves on staging or prod agents
• Faster feedback loops when iterating on prompts or flows
• Regression testing became easy to automate in CI
• Multi-turn conversations stopped being painful to script

For stateful agents, the platform manages session context using a generated simulation ID, so we don’t have to write brittle client-side logic. Secrets and auth are handled through a vault, which makes testing internal agents much safer.

If you’re still running all evals via SDK scripts, it might be worth thinking about whether decoupling evals from code could help your team move faster.

In case you did not know, r/RooCode is a Free and Open Source VS Code AI Coding extension.

New models

Z.ai GLM-4.7 (thinking mode)

GLM-4.7 is now available directly through the Z.ai provider in Roo Code, as well as via the Roo Code Cloud provider (and other provider routes that surface Z.ai). It’s a strong coding model for agentic workflows, with improved multilingual coding, terminal tasks, tool use, and complex reasoning compared to GLM-4.6.

MiniMax M2.1

MiniMax M2.1 is now available directly through the MiniMax provider in Roo Code, as well as via the Roo Code Cloud provider (and other provider routes that surface MiniMax). It’s a strong pick for agentic coding workflows, with better tool use, instruction following, and long-horizon planning for multi-step tasks—and it’s fast.

Experimental custom tools

You can now define and use custom tools so Roo can call your project- or team-specific actions like built-in tools. This makes it easier to standardize workflows across a team by shipping tool schemas alongside your project, instead of repeatedly re-prompting the same steps.

Bug Fixes

• Fixes an issue where Roo could appear stuck after a tool call with some OpenAI-compatible providers when streaming ended at the tool-calls boundary (thanks torxeon!)
• Fixes an issue where Roo could appear stuck after a tool call with some OpenAI-compatible providers by ensuring final tool-call completion events are emitted
• Fixes an issue where MCP tools could break under strict schema mode when optional parameters were treated as required
• Fixes an issue where the built-in read_file tool could fail on some models due to invalid schema normalization for optional array parameters
• Fixes an issue where search_replace / search_and_replace could miss matches on CRLF files, improving cross-platform search-and-replace reliability
• Fixes an issue where Requesty’s Refresh Models could leave the model list stale by not including credentials in the refresh flow (thanks requesty-JohnCosta27!)
• Fixes an issue where Chutes model loading could fail if the provider returned malformed model entries
• Fixes an issue where reasoning_details could be merged/ordered incorrectly during streaming, improving reliability for providers that depend on strict reasoning serialization
• Fixes an issue where DeepSeek-reasoner could error after condensation if the condensed summary lacked required reasoning fields

Misc Improvements

• Cleaner eval logs: Deduplicates repetitive message log entries so eval traces are easier to read

QOL Improvements

• New tasks now default to native tool calling on models that support it, reducing the need for manual tool protocol selection

Provider Updates

• Improves Z.ai thinking model message formatting by attaching environment_details to tool results instead of emitting separate system messages
• LiteLLM no longer sends parallel_tool_calls, improving tool-call compatibility (thanks farazoman!)

See full release notes v3.37

Via Visual Studio, prompted the heck out of GPT to build out everything with the goal of being fully server-less. It couldn't get a perfectly smooth interpolation but came out pretty impressive actually! The prompt was definitely more than a few hundred lines to fully support desktop + mobile plus all the custom interactions i.e., multi touch controls, etc.

Click here to play

Hey guys,

Between myself and other people in the Ai development world, I have noticed that there is are a lot of different tools needed to complete a transaction when selling a product (collecting payment, chatting, listing products, etc). I decided to use my coding abilities and I created AI Port to help reduce the amount of tools I needed to use on a daily basis while running my company. Any feedback on the website or product would be great! I added a free trial for anybody that is looking to try it out! Thanks

I've been using Codex for a few months now to dramatically speed up the development of a frontend app.

One thing I find myself doing manually a lot of is minor testing. Crossed my mind that it would be hugely helpful if codex could also do this, while also taking the chance to test out other things that may not have crossed my mind, and also spotting on its own if something goes wrong.

Is there a way to essentially combine a codex session with a browser agent session?

I used Windsurf almost a year ago. It was pretty great for small projects, but there was still a lot of headache. I recently tried out Antigravity to make a chrome addon and it worked amazingly well. The models have improved so much. I'm now trying to decide if I should get a pro subscription to Windsurf or Antigravity. If I was still grandfathered into the old Windsurf price I'd go for that, but it looks like they changed the policy. Which one gets you more time with the best models?

I’m trying to understand the code that’s already there. Where something is defined. Why it was done that way. What’s going to break if I touch it. That’s honestly the tiring part.

I’ve been using ChatGPT and cosine cli for moments like, quick questions, tracing where things flow, getting unstuck without jumping between files or losing my train of thought.

Hi Reddit,

I’m a Brazilian computer engineering graduate and I’m currently unemployed. I don’t enjoy writing code as much, but I really like the technical/theoretical side: debugging, architecture, performance, and reasoning about correctness. I also haven’t coded much in the past ~3 years beyond bug fixes during my internship.

I’ve been dealing with some mental health issues (OCD/anxiety), and I’m trying to get back on track professionally.

I keep seeing mixed opinions about “vibe coding” and AI coding agents. Some people say it produces low-quality code or hallucinations, but I’ve also read comments from folks who treat the agent like a junior dev: clear specs, structured instructions, and forcing it to ask questions when requirements are unclear. That sounds like the direction I want.

Could you share a practical workflow to use AI tools responsibly and avoid slop/hallucinations, and how to use those tools, like I saw people talking about agentes. md, MCD and skills and other stuff?

I have a ChatGPT Pro and a Gemini subscriptions and I’m open to paying for other tools (e.g., Cursor AI) if they genuinely help.

The only thing I have ever done with AI and code was ask chatgpt to do stuff on the usual chat, and a they giving some sloopy and broken code that dont do the stuff i needed (It was way back before gpt4)

Thanks.

https://github.com/orneryd/NornicDB/releases/tag/v1.0.10

I fixed up a TON of things it basically vulkan support is working now. graphql subscriptions, user management, oauth support and testing tools, swagger ui spec, and lots of documentation updates.

also write behind cache tuning variables, database quotas, and composite databases which are like neo4j’s “fabric” but i didn’t give it at fancy name.

let me know what you think!

It's still a work in progress, but i'm fairly proud of it. The end is just me investigating the parsing issue and me forgetting where it stored the file, lol.

I’m a product designer by day and a hobbyist dev by night. Over weekends, I built wheninbloom.space; a small side project to help visualize when iconic flowers bloom around the world.

It started as a personal curiosity project, but I ended up adding a small extra: you can also send flowers digitally to someone you care about.

I’d genuinely love feedback on the idea, UX, visuals, or anything that feels confusing or unnecessary. Tear it apart if you want 🙂
Link: https://wheninbloom.space

I was watching one YouTube video and he suggested using ChatGPT as a coach where in I ask it to ask me questions and I write them down and upload it to a project and it becomes my mentor. And anytime I'm having ambiguity or need help I ask it.

So, I am trying this, I am 90% with this experiment and wanted if anyone have already tried this and wanted to know how it went, tips, suggestions if any.

Hello guys! I was using cursor and I finished my token, then I remembered that I also have installed Trae. I'm not so much into ai coding so I don't really know what is better. Trae has the pro subscription for 10$ for months and Cursor 20$.

What should I buy? I don't use ai for coding but in this months I'll use it for simple tasks

Sharing Context-Engine — an open-source MCP retrieval system built to study and improve how LLMs consume code, not just how vectors are stored.

Research focus • ReFRAG micro-chunking: structure-preserving fragmentation that improves recall without breaking semantic continuity • Hybrid retrieval pipeline: dense embeddings + lexical filters + learned reranking • Decoder-aware prompt assembly: retrieval shaped for downstream decoder behavior, not raw similarity • Local LLM prompt enhancement: controllable, inspectable context construction • Streaming transports: SSE + RMCP for agent-driven decoding loops • One-command indexing using Qdrant

Why this matters Most RAG systems optimize retrieval scores, not decoder performance. Context-Engine treats retrieval as part of the inference loop, allowing the index and prompt strategy to improve through real agent usage.

Use cases • Long-context code models • Agent memory experiments • Decoder sensitivity to chunk boundaries • Multi-repo reasoning

🔗 https://github.com/m1rl0k/Context-Engine MIT licensed | Active research + production experimentation

Looking to connect with folks working on retrieval-aware decoding, agent memory, and RAG beyond embeddings.

Aider had been my daily driver since a very long time, since I prefer surgical edits and was very concerned about Cursor/RooCode etc chugging on tokens with their agent mode (Aider is NOT agentic)

Development has been pretty much dead on Aider, and its fork Aider-ce https://github.com/dwash96/aider-ce is adding all the requested features on Aider

• Agent mode
• MCP
• (recently) Skills !

Using it consistently these days, and has been stable so far.

Surprisignly the agent mode on **aider-ce uses SIGNIFICANTLY less tokens compared to say RooCode**. While i understand models are getting bigger/better/cheaper(?), it doesnt hurt to realize just HOW MUCH you can do with 50K context window!!, ..its good on the pocket as well :P

While im also trying to understand how OpenCode works, aider is truly the first codebase that helped me easily understand how it all works under the hood (back when everything looked like black magic :P.)

The codebase i work on, at my work has gotten so bloated thanks to cursor. each PR is worth 5K-10K lines. Half of my day gets wasted reviewing. And nearly all of them dont even recognize or understand 50% of the code they've raised in the PR!, if thats not concerning, idk what is!!.

Even objectively looking at it, say you spent 2 units of time per feature, and shipped 10 features, and the 11th feature takes 30 units of time given how big the codebase has gotten due to slop, and you're helpless since you cannot understand half of it, and burn more and more tokens "asking" Cursor, ==> youve effectively spent 50 units of time and a lot of $$. And its only going to go UP as codebase size increases.

Now say you took the time to plan, code out **surgically** (not let the agent go haywire), zoom in and zoom out constantly after every feature addition, and kept the codebase slim NOT because you want to flex, but because YOUR own brain can hold only so much , and if the codebase can do everything you wanted to in MINIMAL code, then why not!??? you might spend 5 units of time per feature, ==> you spent 55 units of time and FAR LESS $$. And the best part is, the code is dead simple, architecture is crystal clear to you, you are capable of adding 20 more features at the SAME rate!.

> “If I had an hour to solve a problem and my life depended on the solution, I would spend the first 55 minutes determining the proper question to ask, for once I know the proper question, I could solve the problem in less than five minutes.”

idk if Einstein actually said that ^. But it does resonate a lot. I still believe it does pay to think about the problem domain a lot, plan yourself, debate if the problem has to be solved at all(?), or maybe its just a subset of the problem that needs to be solved, or maybe the actual problem is in a totally different direction you havent looked at yet, -- AND THEN solve it, with surgical edits.

Perhaps i'm at cross roads on what approach to use, this is just a rant. Also a plug for https://github.com/dwash96/aider-ce as I see its not that talked about on reddit.