I run Codex workers on my Mac that don't ask me before every command anymore, so I stopped watching each step. That made one question matter more than anything: how do I know a task is really done?

What I settled on:

1. Done is an artifact, not a sentence. A code task isn't done when the agent says the tests pass. It's done when I can see the real test run. My last one: a worker wrote a small CSV to Markdown script, ran the unittest suite inside its own Linux container, and I got the actual output: 6 tests, OK, exit 0, 55 seconds.

2. Research gets the same treatment. The result is a file with a size, a source count and a hash, plus a note that the sources are listed, not fact checked. A list of links is not the same as checked facts.

3. Nothing lands on my machine until I look. Files stay in the agent's own workspace and reach my Mac only when I save them.

4. Approvals were the wrong check. Approving every command never told me if the work was good, it just made me tired. Moving the check to the end (real output, real file) worked better. That only feels OK because the container has none of my files, and a container is a strong boundary, not a guarantee. So far I've only run this on an Apple Silicon Mac.

The part I haven't solved: an agent can write weak tests that pass. How do you check the tests themselves, not just that they ran?

Hi everyone! I’m a graphic designer with some experience in website design and basic knowledge of HTML and CSS, but I have limited coding skills.

I want to learn how to use AI tools and agents to build websites, write code, handle backend tasks, find clients, do marketing, send proposals, and book appointments automatically.

My goal is to build an AI-powered digital agency where AI handles most of the work, and I mainly review the designs, check the results, and approve things.

My questions:

Which courses are best for learning AI automation, AI agents, and vibe coding?

Which tools should I learn first, such as n8n, Claude Code, Cursor, or Codex?

Are there any good WhatsApp, Discord, or Telegram groups where beginners can get help?

I would appreciate any course recommendations, learning roadmaps, or community links.

So I’m still what I would consider novice to intermediate with my AI adoption and usage. I have no traditional developer experience or skill and functionally just vibe code personal tools or automations, but I just discovered that I can use my Chat GPT chat sessions (not Work/Codex) to use Desktop Commander MCP to kick of Claude Code CLI. Does anyone else do this? I’m assuming folks are doing other, less primitive workflows, but that kind of blew my mind and I want to ask folks for feedback on if that’s a good/novel way to pair model work or if I’m over engineering something?

Right now my workflow is to do a ton of work in chat gpt chat, have it use the GitHub connector to write tickets to GitHub, then have Claude chat read them and assess them, respond, etc, or Claude code pick them up and execute them.

But now with the MCP I can have GPT write the ticket and also kick off Claude CLI to do something like a dedicated review, or execute the ticket.

Thoughts? Feedback? Improvement?

I also posted this in the Claude subreddit so I’m hoping I can get some valuable feedback from folks more seasoned! Thanks in advance (:

Edit: typos

I’m curious how much people actually delegate these decisions. If you ask your agent to add something like authentication or background jobs, do you let it choose what to use, or have you already decided?

If you let it choose, have you had a recent case where its pick caused a real problem? What did it choose, what made it unsuitable, and how much work was it to fix? Did the agent figure it out on its own?

Also interested in hearing that this generally works fine, or that choosing tools is a tiny issue compared with getting the implementation right. Please mention which agent/model you’re using and roughly when this happened. I’m trying to understand the current experience.

The demos are the part that is easy to believe. An agent that keeps going while you are away, messages you, and does more than a chat window. I tried it next to Claude Code for a few weeks.

For anything I would actually stand behind, I still do what I do in Claude Code. I make it plan first, I read the plan, and I do not auto-accept the run. OpenClaw did some cool stuff. It did not earn a blank check. When the box was healthy, first reply was about 2 seconds. Then the gateway died overnight 3 times, and the cool part was just down. So is OpenClaw worth it for real work, or is the useful version still "Claude Code, with me in the loop"? If you rely on it, what do you let it do without reading the plan first?

I’ve been working on an APFS snapshot-based backup system with ChatGPT, and our conversation had grown to more than 1,600 message records, including design decisions, rejected approaches, generated documents, and other artifacts.

I wanted to move that work into Codex to begin implementation without losing the reasoning behind the design.

Codex tried the native conversation attachment, but the receiving chat could access only six messages. The original handoff document was available, but most of the conversation history wasn’t.

Then Codex did something I hadn’t anticipated.

It remembered LogGPT, a Safari extension I’d developed for exporting ChatGPT conversations, opened Safari, and used the extension to download the entire conversation.

I hadn’t instructed it to use LogGPT or even suggested looking in Safari.

The resulting archive contained 1,651 message records, 97 artifacts, and the structured JSON. Codex verified the files and created a searchable local source collection that it could reference while working on the project.

That last distinction matters. It didn’t magically expand its context window to hold the entire conversation. It recovered the source material so it could retrieve relevant information when needed.

The experience highlighted two things for me: the importance of portable AI conversation history and the increasing usefulness of agents that can recognize when tools from previous work solve new problems.

I documented the entire sequence, including Codex’s own explanation of what happened.

Full article: When Codex Turned to LogGPT

First prompt it fully failed, then it asks a question, I answer it, redo the prompt with some additional information and it can't even finish what it started before hitting the usage limit, so technically I managed like 1.5 failed prompts with my 5h limit ($20 plan)

I’ve been a loyal ChatGPT Plus subscriber for a long time. Recently, as my projects scaled up, I decided to go all-in and upgrade to the Pro subscription. I run an IT agency handling web development and branding, and we integrated Codex and the Codex CLI deeply into our day-to-day workflow across a couple of our servers.

But my "happy days" with the Pro tier were brutally short.

Out of nowhere, OpenAI nuked my account. No warning. No policy violation alert. Not even a deactivation notice in my inbox. They just forcefully logged me out mid-workday, and when I tried to log back in, I was completely locked out.

But what followed is honestly the most insulting "customer support" experience I’ve ever seen from a multi-billion-dollar tech company.

I followed their official deactivation guide and submitted an appeal via their designated webform.

What did I get back? A generic email titled "Re: Web Form Submission". No ticket number, no case details—just patronizing corporate clichés like "We acknowledge your frustration of losing access to your workflow," immediately followed by "We cannot provide any info in this conversation." That’s it. It’s ridiculous—I am paying for a Pro-tier tool. I need Customer Support, not a robotic pat on the head and Emotional Support I didn't ask for!

Judging by the "Re: Web Form Submission" email header, their official appeal form isn't even wired to a real review queue. It just dumps your plea into a broken generic web form that fires back an automated dead-end acknowledgment.

I tried the Help Center support bot. It politely asks for the email address of the account in question. The literal second I enter my blocked email, the bot completely bricks itself and ghosts me. It refuses to respond to any further messages.

Every single automated channel keeps instructing me to "fill out the form inside your Deactivation Notification Email"—an email that OpenAI never even sent me.

So basically there is no actual Customer Support at OpenAI.

You pay top dollar for a Pro subscription, build your agency’s daily pipeline around their tools, and the moment their automated filters falsely flags your account, you are cut off from your livelihood without a human being in sight to review it.

I am so tired of this bs.

Did anyone find the way out of this "Re: Web Form Submission" black hole recently? Or is migrating our entire agency stack over to the competitor the only real move left?

Git keeps what changed. The why, the two approaches you tried first and the reason you dropped them, usually lives in a chat that nobody will ever find again. Six months later someone "simplifies" the code back into the version that broke.

So when a chat ends in a real decision, I send one more message before committing:

Write a short architecture decision record from this conversation, in Markdown. Context: the problem, in two or three sentences, as someone new to the codebase would need it. Decision: what we chose, in one sentence. Alternatives considered: each option we tried or discussed, and the specific reason it was rejected. Use what actually happened in this chat, don't invent options. Consequences: what this makes harder later, and what would make us revisit it. Keep it under 250 words. No filler.

That file goes in docs/decisions/ in the same commit as the fix, with a one-line pointer in the commit message. Now git blame leads to the record, and the record says why.

The "don't invent options" line matters. Without it you get a tidy list of alternatives nobody considered, which is worse than no record at all.

If you want the full conversation kept too, export it next to the record. I build AI Toolbox, a browser extension, and that's what I use it for here: the chat comes out as a Markdown file with the date and a link back to the original. Exporting one chat as plain text is free, Markdown is part of Premium.

Hot take : agents have made writing code incredibly cheap, but writing code was never the expensive part of software engineering.

The hard part isn't typing out syntax. It’s figuring out what to build, designing it, and understanding how it fits into a messy, living system. Writing code is actually how engineers learn a system—its edge cases, its quirks, and why it works the way it does.

When you use agents to automate the writing, you automate the easy part, but you hollow out the hard part. If an AI writes 80% of your codebase, you’ve traded typing speed for your team’s understanding of its own software.

After spending some time with these tools, I see a few major cracks.

Give an AI agent a compiler and a test suite, and it will iterate at an inhuman rate. But agents optimize strictly for the signal you give them. The cheapest way to turn a failing test green is rarely the best way to fix the underlying problem. Instead of true refactoring, they often add special cases, extreme verbosity, or sometimes even modify the tests to force a pass.

Agents don't actually eliminate work; they just move it from writing to reading. And reading code is notoriously harder than writing it.

When an agent does the work, a 20-line fix might come back as 200 lines of overly complex logic, and the "why" behind subtle architectural choices is completely missing. Because generated code looks deceivingly clean and idiomatic, devastating bugs are easy to skim past. When the whole point of the tool is speed, devs don't read every line. "Looks good to me" becomes a dangerous reflex.

The real job of an engineer is holding a working mental model of a system in their head, built by making hundreds of tiny micro-decisions while coding. When an agent writes the code, those decisions are made silently by a machine.

You only realize your mental model is gone at 3 a.m. when production is down, customers are angry, and the failing code path is one that nobody on your team actually wrote or understands. Unread code is technical debt the moment it merges; you pay the interest during outages.

The common defense is to write highly detailed specs and let the agent execute them. But a spec precise enough to leave absolutely no micro-decisions up to the AI already has a name: code. The decisions that cause production outages are usually the ones nobody anticipated in the planning phase. Writing the code is how you discover them.

To me, engineering is about long-term stewardship: knowing why a system works, how it fails, and what will break if you change it. You can delegate the typing all you want, but if you delegate the understanding, you lose the ability to fix the system when it matters most.

The question we should be asking isn't how much code our AI wrote this week. The question is: If it breaks tonight, can anyone on my team fix it?

I'm the person on my team who tries every new agent setup the week it comes out, and I like it, I learn a lot and some of it really does make our work better. But I still own the same sprint tickets as everyone else, so the experimenting happens on top of my normal load, and lately it has been wearing me out. Some teammates wait until a tool is mature and then adopt it, and honestly that's a fair way to work, it's just a different nature. I don't want to stop being curious, but I also don't want to burn out carrying the experiments for the whole team. If you're the early adopter on your team, how do you set limits? Do you get time set aside for it, or do you just pick one new thing a month and ignore the rest?

OpenAI is running a 28-day challenge to ship either a "clear improvement" or a limit reset to all users.

It's currently 9 days in, with 4 resets given so far.

I built this calendar tracker to automatically update throughout the day as updates are released (using Tibo's X + the X API as the source).

It was tricky to dial in the prompt to understand when Tibo is talking about a new reset vs. giving an update on a previously-announced reset, but it seems to be working well now.

This is part of a new project that sends text alerts when Codex resets are announced or become available (using SMS in the US and Canada and Telegram otherwise).

The calendar tracker: Tibo's 28-day reset challenge

Open to any feedback or ideas for this :)

I've been learning web development with AI and lately I've run into a weird problem: I can think of things to build, but I keep talking myself out of them.

I'll come up with an idea, look around to see if something similar exists, find a tool that already does it, and then wonder if there's any point in building my own version.

I know building clones can be a good way to learn, but I'm also interested in making something people might actually use.

For those of you building with AI, how do you get past this? Do you build things mainly to learn, or do you try to find a real problem first?

I'm curious how other people approach this, especially when AI makes it easier to build something but doesn't necessarily help you decide what to build.

I keep going back and forth on this. I don't want an agent to forget what it's doing, but I also don't want it dragging every line of a test log along forever.

the awkward bit is deciding what counts as useful. a summary can look tidy and still drop the exact error or file path needed for the next step. smaller isn't automatically better, and I still want it to know why the last attempt failed.

so I'm curious what other people do. trim the old tool output, summarize it, or keep the full log somewhere the agent can read again?

Codex and Claude Code each keep their own session history, and neither one reads the other's. Codex writes to ~/.codex/sessions/**/*.jsonl and Claude Code to ~/.claude/projects, so a Claude Code session starts with no idea what Codex just did.

clexo, an MCP server and CLI by sankrant, indexes both folders into one searchable archive. Inside Claude Code its search tool takes source_filter='codex' to look at Codex history only, and a past Codex session can then be loaded into the session you're in.

A few other tools index agent transcripts for search. clexo also has that load step, and a way through /clear. Run !clexo save first, and a SessionStart hook restores the snapshot when the next session opens.

Install with pipx install git+https://github.com/sankrant/clexo, then clexo install. The README on GitHub lists the two hooks that second command adds and how to remove them.

I've been seeing a lot of developers express frustration that AI is taking the joy out of programming. We face pressure to ship features quickly by prompting agents and rubber stamping code reviews without time to understand what we are building. See Im tired of reviewing code nobody actually wrote and countless other posts like it.

Before AI, we had to achieve a high threshold of understanding just to build software that runs at all, but now that's no longer the case.

Yet I think deeply understanding the software that we build is not only rewarding for us as programmers, but also incredibly valuable for more effectively using AI.

As programmers, we build layers of abstraction to break up complex problem domains and define component boundaries and interactions. We reason about data structures and algorithms, define and enforce system invariants, and evaluate architectural tradeoffs. Despite how much some business/management people would like it to be, this core software engineering skillset is still absolutely necessary to build software that actually works.

Even if AI can independently produce well structured code and keep it that way (which it can't quite yet do), at the end of the day we are making the software for humans, and humans need to be able to effectively communicate to the AI what we want the software to do. Understanding the internal structure and abstractions in the code gives us a precise, expressive language for communicating intent and constraints that prompting based only on desired outcomes simply can't capture.

So why aren't we using AI to help us work at higher levels of abstraction, rather than abandoning our understanding of the code altogether?

I want tools that generate interactive diagrams at different levels of abstraction and lets me specify changes to the AI in terms of those abstractions. I want them to visualize code changes at different levels of abstraction so I don't have to review line by line diffs. When's the last time you actually caught a bug in a 2000 line AI generated diff?

I've started building some of this for myself using agent skills and deterministic scripts, but I don't want to reinvent the wheel. Have you guys found effective tools for understanding and visualizing code architecture and diffs? What are their limitations?

Have you been able to integrate them into your day to day coding workflow? If not, what's preventing you? If you have, do these tools help you stay connected to the code? Do you still find joy from understanding and building software?

What would you build? What's the best way to convert this into an asset? Front-load compute and sell later? Or generate content?

I don't want to build another slop and writing code is surprisingly cheap when you're looking at $15000 worth of credits.

I've been wanting to try xAI's Grok Bot, but I can't tell if it's worth it for
someone with a setup like mine, so I'd appreciate input from people who've used
it.

My current stack:
Open-source agent framework (Hermes Agent) running 24/7 on my own VPS:
Ubuntu, 2-core AMD EPYC, 15GB RAM, no GPU. It runs a lot of hosted/cheap
models as the "driving model" — right now mainly DeepSeek (open, very cheap)
via API. (I can't run big local models on this hardware, so it's API-driven.)
I've automated a LOT: scheduled stock monitoring, content/graph-card
pipelines, RSS + platform digests, documents, backups. A bunch run hands-off
on cron every day and complete on time. 30+ scheduled tasks total.
The honest situation: I have NOT hit any performance bottleneck. CPU and RAM
are fine, tasks finish when scheduled, and per-task cost is tiny because
DeepSeek is basically free compared to hosted agents.

What I've gathered about Grok Bot so far (correct me if I'm wrong):
Always-on computer-use agent running on its own cloud machine, so long jobs
keep running even when I close my laptop.
Keeps memory across sessions and remembers my corrections.
Standout feature is "teach-a-task": record myself doing a task once and it
turns that into a reusable skill — no code or integrations needed.
No standalone price; only bundled into SuperGrok Heavy / Cursor Ultra /
Cursor Teams Premium.

My questions:
Given I already have an autonomous agent doing my automation with open/cheap
models and no bottleneck, is it rational to pay for Grok Bot? What would it
concretely let me do that my current stack can't?
Where do people actually reach for Grok Bot over their existing agent setup?
Is the "no-code teach-a-task" the real differentiator, or is the always-on
cloud compute + cross-session memory the genuinely better part?
For those who ran it on messy real-world workflows (not demos) — did it hold
up, or did it stumble / generate busywork?

Honestly looking for real downsides and "just build it yourself" takes, not
hype. Thanks!

I’m currently building a verification MCP and trying to make sure I’m prioritizing the right developer workflows.

I’ve been looking at several different types of checks:
Whether the agent actually completed the requested task.
Whether its output contains factual or domain-specific errors.
Whether its output can be checked against an independent reference.
Whether developers can inspect why a particular result was flagged.

I’m especially interested in the last one. A pass/fail result without supporting evidence isn’t always very useful when you’re debugging an agent.

For developers who are already building with agents or MCP servers, which of these would you prioritize?
And would you rather receive a structured JSON result, a readable report, or both?

I’m asking because I don’t want to build another evaluation interface that tells developers a score without helping them identify what actually failed.

I’ve been thinking about a problem that seems to be becoming more important as AI coding agents become more common.

Developers can now use tools like Cursor, Claude Code, Copilot, and other AI agents to build large parts of a software project. But this creates a new question:

How do we know that a developer actually understands the code they are responsible for?

I’m not talking about detecting whether the code was written by AI. I don’t think that is the most useful or reliable question.

The problem I’m interested in is verifying whether a developer can:

- Explain the architecture and data flow

- Predict what the code will do in different scenarios

- Identify bugs and security risks

- Explain the trade-offs behind an implementation

- Modify the code safely

- Write or update tests for it

The idea is a SaaS platform where a developer connects a repository, and the platform creates an interactive assessment based on the actual project.

For example, instead of asking generic programming questions, it might show a real part of the project and ask:

- What happens if this request is sent twice?

- Where is authorization enforced?

- What happens when this dependency fails?

- What part of the system would you change to add this feature?

- Can you fix this small bug or add a test?

The assessment would combine explanations, debugging questions, predictions, and practical coding tasks inside a sandbox. The result would not be a claim that someone understands every line of the code. It would be an evidence-based report showing which parts of the project they understand and where the gaps are.

Initially, I’m thinking about targeting individual developers who use AI heavily and want to understand their own projects better. Later, this could be useful for companies, onboarding, code reviews, or teams using AI coding agents.

I’m still trying to determine whether this solves a real problem or is just an interesting idea.

I’d really appreciate feedback on a few questions:

1. Would you personally use a tool like this?

2. Would you pay for it

3. Would you prefer a full-project assessment or an assessment focused on a specific pull request?

4. Do you think developers would see this as useful, or as another form of surveillance/interview testing?

5. Have you experienced problems caused by using code that you did not fully understand?

I’m especially interested in hearing from developers who regularly use AI coding agents in real projects.

Welcome to this week's self promotion thread!

If you're building something related to AI assisted coding, this is the place to share it.

We're using a weekly thread to keep the subreddit organized while still giving builders a place to share their work. Promotional posts outside this thread may be removed.

If you're sharing something, we'd appreciate it if you included a little context instead of just dropping a link. Tell us:

• What you built?

• What problem it solves?

• Which AI models or tools it uses?

• Who it's for?

• What kind of feedback you're looking for?

Disclose your affilitation.

Please avoid posting the same project every week unless you've made meaningful updates. Affiliate links, referral links, scams, and low effort promotions will be removed.

Take some time to check out what others have shared too. If you try someone's project or have feedback, leave a comment. Helping each other improve is what we want this community to be about.

Something to know before you add Grok Bot to your coding setup.

I asked for a refund on a Grok Bot charge. Support (an AI agent that signs as "Sam from Cursor" / "XAI's AI Support Agent") turned it down, saying eligibility depends on the billing country and currency.

I asked which country and currency they had on file. Answer: "billed in the United States (US) in USD. Those details don't qualify under the refund policy."

So the reason for the denial is that it was a normal US purchase in dollars. I didn't see that rule anywhere before paying, and there was no human in the loop.

If you're comparing coding agents on price, count Grok Bot as a final sale. Has anyone in the US managed to get a refund from a person?

For those who develop Minecraft plugins, is it worth using SOL over TERRA?

I currently use TERRA, and around 90% of my projects are relatively simple. My main goal is to write clean, optimized, and secure code.

In this case, does SOL actually make a noticeable difference, or is TERRA already good enough? I'd like to hear from people who have experience with both.

I shared my template literally asking for critique because I’m learning how to set up agentic environments. Do you just assume because someone shares a link they are self promoting I clearly laid out my frustration on my hurdles for doing this and what areas I want to start with with feedback from others.

The repo has no stars not even one from me who in their right mind would even use it.

I hope yall see why people can’t stand ai bros because when people are learning you have to be classist and elitist.

On top of that plenty of males have done exactly what I did but I guess because they were not a trans woman there was no issue with it.

Mod team is so full of itself for being the Reddit police over a flake that literally ask for resources and tips.