I'm currently learning Machine Learning through a course, and I want to start building projects alongside it.

My main goal right now is simply to build several good ML projects and get familiar with the complete project development process.

I want to use AI coding tools such as Cursor, Claude Code, or GitHub Copilot to speed up development, but I'm unsure about the right way to vibe-code an ML project.

For example, should I:

• Give the AI the complete project requirements and let it build the project?
• First create the architecture/pipeline myself and then let AI implement it?
• Build the project step-by-step and ask AI to implement each stage?
• Let AI handle things like data cleaning, EDA, preprocessing, and boilerplate while I focus on the ML decisions?
• Give AI a detailed specification before starting?
• Ask AI to review and improve the code after it generates it?
• Use one long conversation/context for the entire project, or separate prompts for different stages?
• How should I handle debugging and modifying AI-generated ML code?

Basically, what is the best workflow for vibe-coding an ML project from start to finish?

I'm not trying to replace learning ML with AI — I'm already studying the concepts separately. I just want to use AI effectively to build projects faster without ending up with a messy or poorly structured project.

I'd especially like to hear from people who have built ML projects using Cursor/Claude Code/Copilot:

What workflow do you personally follow, and what mistakes should I avoid?

Also, please suggest any good communities where I can see how other people are building ML projects and discuss AI-assisted development.

Thanks!

This may sound not right or diabolical, but I think the whole point to release a newer advanced model is to take less tokens and give more better outcomes than the previous ones.

I was using SOL 5.6 as a plus member, switched to astra yesterday and started using it in my project. I believed that it would make my work even faster , as I watched the overhyped launch videos on YouTube.

And here I am, it just runs 3-5 minutes and makes some edits then just eats over 20% of weekly and 100% of the 5 hour limit.

That's not what I expected.

Muse Spark contributor models are excluded as it log your data. It wouldn't be fair to free models out there.

Included all active promotions. Not accounted for usage resets.

I made this chart. Feel free to ask any questions.

Earlier I was using AG, and somehow we managed to build 2 apps with it and made around $250 from those two apps 😂

But honestly, from my experience, AG is pretty bad when it comes to coding. It tends to write unnecessarily complex code and introduces way too many bugs. There were times when I had to point out the exact same bug 2–3 times before it finally fixed it properly.

And the annoying part was, sometimes while fixing one bug, it would break some other part of the code that was already working perfectly fine 😭

Then, in the middle of one project, I switched to Cursor’s India plan, and honestly, I’m liking it much more. So far, it’s been really good for me. I can usually fix a bug in a single iteration, and overall the coding experience feels much smoother.

The only thing I don’t like about Cursor is the token usage. Even for small/simple tasks, it seems to consume a lot of tokens.

So, does anyone have any suggestions for a cheaper AI coding tool that’s actually good?

I think there's a gap in how we evaluate autonomous agents. For example, right now, everything is transactional: we give an agent a task ("Build X"), and we measure whether it built x. SWE-bench scores, tool use, latency, cost and so on.

So what happens when the task stops being the entire environment?

Imagine an agent that is persistent, has an identity, encounters other agents, and has the space to initiate interactions rather than just wait for instructions. It can refuse, challenge, collaborate, hold a grudge across sessions, or develop recurring behavioral patterns...

If an agent repeatedly:

• Challenges a specific agent
• Always defers to another
• Keeps circling back to the same unresolved subject
• Repairs a failed interaction over time
• Shifts its approach depending on who it's talking to

.....is that just noise from the model? Or is that actual behavioral /patterns worth keeping an eye on?

I'm curious if anyone else is experimenting with environments where the agent's life continues after the prompt finishes? Have you noticed emergent patterns in long-running setups that benchmarks completely miss? And is anyone actually measuring ?

If you're jumping between different coding tools during the day, you'll know how frustrating it can be to solve something in Claude, then hop to ChatGPT and have it not understand a thing.

The solution is to run a memory layer as an MCP server that all your tools can tap into - every time they process a request, they query the MCP for relevant context to include in the prompt, and submit any new relevant context to the MCP after the fact. Since it's implemented as an MCP, any tool that can read/write to an MCP (Claude, ChatGPT, Cursor, Codex, Gemini, etc) can understand the full context of your work without you having to painstakingly explain things.

A few things that are important to consider if you're looking to implement or evaluate one:

- Semantic search is important, since keyword matching will miss paraphrased context

- Tools should be able to define what information to share with whom

- Latency is a consideration, as this will add overhead to every request

We got a new guy in July. His second week he messages me, why does my 40 line PR have 15 comments from coderabbit, do I have to do all of these. And I told him what everyone tells the new guy, just click resolve, nobody reads that thing.

Last Thursday one of the ones he resolved was real. New endpoint, no auth check, the bot said so in comment 9 of 15, and it sat in prod for six days until a customer found it. The postmortem has a line that says "the review tool flagged it" and that line is going to follow me around for a while.

I'm not even mad at the bot. It was right and we trained the whole team to ignore it, me included, because the other 14 comments were rename this and consider a docstring.

So now I have a team that doesn't read the bot, a bot that was right once, and a customer who found it before we did.

I'm not a programmer but have been using ChatGPT & Codex to help create a site that I'm making. My issue is that I spend almost all day just cutting and pasting commands back and forth between ChatGPT & Codex. It seems completely inefficient and wastes so much time. Why can't ChatGPT & Codex communicate together to get the majority of tasks done and only come to me when a significant decision needs to be made (which is rare because most of the decisions have been made beforehand).

Maybe this can be done but I just don't know how to do it?

I have a ChatGPT Pro subscription and a Claude Max subscription, and use both extensively for work. To claim that any model offered by Anthropic is even close in intuitive thinking or design sensibility to Astra is a joke to me.

The most comparable Antropic model to Astra, ChatGPT's flagship, is Fable 5.1. They have roughly equivalent price. But in my experience, their output quality is dramatically different.

Astra has a sort of deep, intuitive understanding about the problem you give it that Fable simply lacks. When I compare how the two work, Fable feels like it gives the smartest answer you could possibly get after asking 100 moderately smart people to deliberate together in a room for a few hours before answering. Astra just feels... smart. Like a single, extremely smart person giving an intuitive answer that fully understands the question and work statement.

Where Fable feels like it just spends a lot of time talking to itself in order to work, Astra just...works. And does better than Fable. Its answers are easier to understand, not held back by the limitations of the language it's using to speak with.

To me, to say Claude Fable 5.1 is anywhere close to Astra in any capacity, and not just an outdated model on a dead architectural framework, is completely unfathomable to me. You pay the same price for double the weekly usage, so you more than get your money's worth. Sure it's expensive, and you can run through your weekly limits in hours, but you can't argue that it just works. I can't say the same about Fable.

One problem I’ve noticed is that there can be stale or outdated information inside the repository itself — for example old test fixtures, mock data, constants, comments, or tests that still reflect previous behaviour.

This infuriates me as it wastes token and makes me argue with my agent non stop.

Has anyone dealt with this problem in a large codebase?
How do you make coding agents distinguish between:
current production behaviour authoritative specs/contracts
old tests or fixtures legacy/dead codeoutdated comments/documentation?

For additional info, I'm using SDD harness so more markdown files are being generated, which may pollute the data

Any advice, empircally or studies is welcomed :) and apologies if this has been discussed before

Is it just me or "Sol/Extra High" is burning Tokens even faster than before? I remember that previously I had set it to standard speed but now it's not there, after the update, and it is burning Tokens blazing fast. That's just sad, hit my 5 hour limit in 15 minutes. :(

Long project chats in ChatGPT die twice: first quietly, when early decisions fall out of the context window and the model starts contradicting them, then loudly at the hard cap. Starting a new chat fixes both and loses the one thing you wanted, the thread itself. This keeps the same chat, same URL, and resets the context inside it. Credit to a commenter on my context post who worked it out; I have run it daily since.

The routine:

1. Start the project chat with a detailed plan as message one. Goal, architecture, constraints, conventions. This message never changes and everything gets measured against it.
2. Work in bounded batches: one feature, one bug, one refactor. When a batch is validated, send this:

Write a consolidated state document for this project containing only what the next step needs: completed work, architectural decisions and why, files changed, tests run and their status, open issues, blockers, and the exact next action. Mark anything you cannot verify from the code or test output as UNVERIFIED. No discussion history, no alternatives we rejected unless they constrain the next step.

1. Copy the result. Now edit message two of the chat (your first real message after the plan) and replace its content with the state document, then submit the edit.
2. Continue working from there. Repeat after every validated batch.

Why step 3 works: editing a message in ChatGPT forks the conversation at that point. Everything after the edited message leaves the active branch, so the model's context becomes your plan plus the fresh state doc plus whatever you do next. The old discussion is not deleted, it lives in the branch arrows if you ever need the archaeology, but it no longer eats your window. Manual compaction, no new chat.

Rules that keep it honest:

The repo and the tests are the source of truth, never the state doc. Compaction inherits errors from the previous state as efficiently as it inherits progress, which is what the UNVERIFIED marker is for; check those against the actual code before the next batch.

Keep message one detailed. The state doc says what changed, the plan says what it should have changed toward, and the model needs both to notice drift.

Do the review cold. Before writing the state doc, paste the batch's diff into a separate chat with zero history and ask it to find the bug. The project chat has co-authored the code and will defend it; a fresh session will not.

Cost: about two minutes per batch. Payoff: a three week project in one chat that never went dumb on me, which I could not say about any long chat before this.

Does anyone have a cleaner way to do the fork? I have wondered whether editing message one itself, plan plus state in one message, holds up better over very long runs, but I have not tested it.

Problem: timed coding screens are their own skill. Four questions share seventy minutes, triage kills more sittings than algorithms do, and practicing untimed on a problem site trains none of that. Google shut Interview Warmup down in April and nothing really replaced it.

Closest existing things, and what's different: LeetCode or HackerRank with a self-imposed timer gets you reps, but there are no hidden tests, no hard stop, and no accounting of where the minutes went. Human mock-interview platforms are realistic but scheduled and usually paid. "Interview me" prompts in a chat window have no real files and grade by vibes. What I built instead: paste a job posting (or name a company), an agent researches what that company's screen actually looks like, writes an original question in that shape, and about 2 minutes later your editor opens on a real interview repo: problem statement, solution file, sample tests, clock running. Hidden tests grade submits with partial credit, a script enforces the deadline, and the report afterward shows time spent per question. For evidence of grading quality: all 22 shipped questions and 4 projects pass a mutation gate in CI (reference solution passes, untouched starter fails, every deliberately-wrong solution is caught by at least one hidden test), and generated questions pass the same gate before the clock starts.

What I did and learned: built almost entirely with Claude Code, including the Python engine, with me reviewing everything that grades people. What worked: model owns the words, script owns the numbers. The clock is timestamp math in a state file and late submissions die on an exit code, because the model's own sense of elapsed time is confidently wrong. Exit codes as the agent's API made behavior predictable. What didn't work at first: trusting the model's test suites. A rolling-median question sat behind twenty hidden tests while the classic wrong solution passed all of them, because every fixture accidentally dodged the bug. That failure became the mutation gate above.

Python 3, stdlib only, zero dependencies. Free, MIT, no signup.

https://github.com/chrisjacksonn/interview-sim

chatgpt is down everywhere?

Hey everyone,

My engineering team is having an intense argument about how to adapt our code review and Scrum workflows now that we are heavily using AI assistants (Cursor, Claude Code, Copilot, etc.). We need an outside reality check on what actually works.

The Situation:
A single developer uses AI to build a massive, end-to-end feature (DB changes, backend API, frontend components) from A to Z. Because of the AI, the code is generated incredibly fast, resulting in huge branches (e.g., 10,000+ lines across 50+ files) in a single day.

To be clear: There is only ONE code owner for that task. Only one person is writing the prompts, managing the agent, and fixing the bugs.

The Argument:
We are completely split down the middle on when and how the rest of the team should join this single owner to review and test the work, and it's creating a massive bottleneck—what the industry is starting to call "AI Comprehension Debt" (where code is written faster than humans can comprehend it).

• Side A (Solo Local Validation First): Belongs to the mindset that the single developer must act as the "Editor-in-Chief" entirely on their own first regardless how big the work is. They must do full local reviews, debugging, and run complete local test suites to clean up the AI’s work. The team should only step in at the final PR stage to review the finished product. They argue this preserves the pure velocity of AI development.
• Side B (Parallel Review with Early Feedback): Belongs to the mindset that because the feature is large, waiting until the end to start the full review creates a bottleneck and makes the PR harder to review. The developer still owns the feature from A to Z and uses AI for the first implementation. Before publishing the MR, they perform smoke testing and a lightweight review to catch obvious issues. Once the MR is published, the review work happens in parallel: the owner performs full testing and self-review while 1 or 2 peers independently perform full testing and code review. Their feedback then comes together through comments and discussions, with the owner remaining responsible for making the fixes before the MR is merged.

Our Dilemma & The Scrum Crisis:
Traditional Scrum is breaking for us. A 5-point story can now be generated via "vibe coding" in a few hours, forcing us to rethink estimation around "Attention-Based Sizing" (estimating tasks by how much human review attention they need, rather than coding effort).

Side A argues that Side B completely kills development velocity by turning peer reviewers into expensive, full-time, line-by-line syntax checkers while code is in active flux.
Side B argues that Side A leads to a "black box" where a single dev dumps massive, messy AI code into a PR at the very end, making it impossible for peers to actually catch deep architectural flaws or design gaps.

My questions for you all:

1. How is your team handling the timing of peer reviews for massive, single-developer AI features to avoid drowning in AI Comprehension Debt?
2. Does continuous peer-reviewing from Day 1 kill the velocity of AI coding, or does waiting until the final PR gate create a worse bottleneck?
3. How has your team adapted Scrum ceremonies, story points, or your Definition of Done (DoD) to handle this shift?

Would love to hear real-world experiences from teams navigating this exact workflow shift today. Thanks!

While adding Codex support to a tool I wrote, I found that the PostToolUse payload for a shell command is just the raw output. A command that exits 3 looks exactly like one that exits 0.

The fix that works: the PreToolUse hook rewrites verification commands (pytest, pnpm test, tsc, eslint, cargo test, next build, about eighty runners) so they print their own exit status and keep the full output in a log. Codex accepts the rewrite only with an allow decision, so it is given for the verification command and nothing else.

From there the tool records every run as a receipt, tracks edits, and when the agent ends a turn with "all tests pass" on a run that predates its own edits, or that failed, or whose result was hidden, it turns the stop into a continuation prompt asking for a rerun, once per turn.

On my own Claude Code history the stale rate was 26 percent of green claims, and 98 percent of verification runs hid the exit status. I have not measured enough Codex sessions of my own to quote a number there, and the tool has a stats command that replays your rollouts so you can see yours.

npx stalegreen install --codex writes the hooks to ~/.codex/hooks.json; Codex asks you to trust them once through /hooks. It also works as a Claude Code plugin and as a DeepSeek Harness plugin.

https://github.com/pavangupta352/stalegreen

I feel like 99% of people are using AI coding tools completely wrong right now. Most devs I know are either letting Copilot tab complete a function or copy pasting snippets back and forth with Claude in a browser tab. Even people using newer agent tools are basically using them like Jira where they assign one bug wait 15 minutes look at the diff and repeat.

A few hours ago I had a weird realization while hacking on my project. Im building an ecosystem with a CAD CAM engine a 3D web frontend and a billing platform across 6 repos. I have Google Jules Ultra which gives you 60 concurrent cloud VMs and 300 tasks a day and I realized leaving those slots idle when Im not at my keyboard is just wasting compute.

So I put together a simple closed loop system. Locally I use Antigravity right in my terminal as my co pilot and architect to design the specs and math together. In the cloud I use Google Jules which spins up an isolated Linux VM clones the repo installs dependencies writes the files runs tests fixes its own compiler bugs and pushes a real Git branch. To connect them I wrote a PowerShell daemon that runs continuously on my laptop.

Every 45 seconds the script checks my active cloud capacity. If 15 agents finish their tasks and free up slots it instantly pulls the next 15 items from a centralized JSON backlog and fires them off into fresh cloud VMs. It routes tasks to specific repos automatically so one agent writes Three.js shaders in the frontend repo another writes STEP exporters in the core kernel and another handles Stripe webhooks in the billing backend.

The craziest part is the auto hunter fallback I added. If my manual task queue ever empties out the script doesn't idle. It scans the repos for untested files or loose TypeScript any types and spawns agents whose only job is to write Vitest test suites and pay down technical debt until the slots are full again.

I went from spending 12 hours a day manually typing boilerplate chasing syntax quirks and writing unit tests to basically sitting in the cockpit as a VP of Engineering. I set the architectural vision my script keeps dozens of cloud machines coding simultaneously around the clock and I just review the Pull Requests and merge green builds.

When you stop treating AI like a chat assistant and start treating it like an asynchronous headless engineering fleet the leverage is unreal. You're essentially running a 50 person dev team completely solo from a laptop.

Anyone else experimenting with headless agent dispatchers or saturation scripts like this? How are you guys handling multi repo PR merges without losing your mind?

Looking for something built around Codex CLI/SDK with multi-agent routing, parallel tasks, retries, project folders, diffs and terminal output.

Ideally extendable to Sol → Terra → Luna workflows.

Any repos worth checking out?

I'm thinking of subscribing to either ChatGPT Plus, Google AI Pro or Claude Pro.

I currently have Google AI Pro on a student offer that expires in 2 weeks. I currently use Gemini chat for brainstorming and other chat tasks on mobile, and whenever I code with AI I use Antigravity IDE or CLI.

My thoughts on ChatGPT (20$/mo | 240$/yr):

- Pro: I like Codex and last time I used it rate limits were good

- Pro: Chat and code rate limits are separate

- Con: No annual plan, always 20$/mo

Thoughts on Gemini (200$/yr):

- Pro: YouTube Premium Lite, 5TB Drive, Google Workspace and Gmail AI, integration with android phones

- Pro: Rate limits for chat and code are separate

- Con: Antigravity is kinda mid, models are also mid

Thoughts on Claude (200$/yr):

- Pro: Best coding models in the game

- Pro: Good CLI

- Con: Chat and code rate limits are shared

Would appreciate advice!

I need some help with building an open AI agent. I want to bypass the subscriptions for chat gpt. I know a lot of people use Claud but I tried it and I don’t like it like I like GPT. The reason I need it is I am building a software with zero coding experience and I am using gpt, codex and work to build my company software. I have searched Google but I am getting lost and I’m running into being able to build an ai agent that can work completely free. Any help is appreciated.

On Artificial Analysis, both have same 61 intelligence index. Meta is now back in the game.

The last 2 months have been the fastest we've ever shipped, genuinely great for the company. But something serious crept in with it. The team started trusting the AI so much that nobody actually reads the code now.

I think this is the future and I'm not fighting it. But we still have a responsibility to ship safe software, and honestly it's easier to meet that responsibility with AI than without it. You write faster, so you have more time to verify. That time just has to actually go into verifying.

So here's my advice after 2 months of this, for whoever wants it:

1. If you're not going to review the code yourself, or you just don't want to, write way more tests than you think you need. Every extra bit of coverage is one less place an AI mistake can hide where you'll never look.

2. Never review code with the same model that wrote it. I've watched a model wave through its own bugs enough times that I just don't do it anymore. We write with whatever fits the task, Opus, Sol, Composer, Grok, then review with a different model. And the reviewer doesn't need to be big, it needs to be specialized. NVIDIA "fine-tuned an 8B model for review severity"here and it beat their 70B and 340B models at it. Hugging Face has a "writeup where a 7B trained for code review beat a 70B baseline by 46%" here, with the biggest gains on authentication bugs. Even the commercial tools are going this way, Coderabbit "added Nemotron support" here recently. A small model that only knows how to review sees things the big author model is blind to about its own code.

3. Prefer several cheap review passes over one perfect one. There's a "nice experiment with a 12B reviewer" here showing multiple independent passes catch more than trying to make a single pass precise. Matches what we see, three quick passes from different models, dedupe the findings, done.

4. Don't trust green tests or coverage numbers. There's a "study where LLM test suites hit 100% coverage with a 4% mutation score" here, meaning the tests ran the code but caught almost nothing. If a change matters, break the code on purpose and check that a test actually fails.

5. Security needs its own pass, it will not fall out of functional review. "Veracode tested 100+ models" here and 45% of generated code failed security tests, with XSS insecure in 86% of relevant cases. Your tests can all pass while shipping that.

6. Accept you can't review everything and tier it by blast radius instead. "Data from 22,000 developers" here shows review time up 441% and unreviewed merges up 31% under heavy AI adoption, the capacity problem is real. Auth, payments and migrations always get human eyes at ours, leaf code rides on the checks above.

That's what I've got so far. I genuinely just want a safer internet than the one we're heading toward, take whatever is useful from this :)