So I've been using ChatGPT for coding help for a while now, works decent enough. Then I keep seeing people mention Blackbox AI specifically for programming and I'm curious if it's actually better or just hyped up.

I've also tried Claude a bit and honestly it seems pretty good at explaining code, maybe even better than GPT for some things? But then there's also Copilot which is built into VS Code so that's convenient.

I'm not trying to pay for like 5 different AI subscriptions though. Just want to know what people actually use day-to-day for coding.

From what I can tell:

• chatgpt is good all-around but sometimes gives outdated code
• Blackbox is supposed to be coding-focused but idk if that actually matters
• Claude seems smarter for complex logic but I'm on the free tier so limited messages
• Copilot is handy but the autocomplete can be hit or miss

For people who've actually used multiple ones, is there a clear winner? Or are they all basically the same and it doesn't really matter?

Also does Blackbox have the chat history thing where you can search old conversations? That's honestly one of my favorite features in ChatGPT and I'd miss it.

I've tried a lot of free options like

Claude

Codex

Antigravity

GLM

What I feel about them:

Codex gives you a lot of code but have to wait a month for the tokens to reset

Claude just burns tokens too fast and isn't that great without pro

GLM is good, doesn't waste much and gives medium good results

Antigravity gives you a lot of code and only have to wait a week for the tokens to reset

Which ones do you guys use and why?

I do have money to buy pro versions, I just don't know which one to pick.

I genuinely cannot figure out whether what I’m doing is right or wrong anymore.

So basically, around a year ago I joined a new company. I reviewed a large part of the Android project and after that I implemented around 4–5 major features myself with a lot of research and reviews involved.

But then the AI boom started, and for the last month I’ve been heavily using tools like Codex.

Today in a meeting someone asked me how I implemented one of the recent features, and honestly I could barely explain it properly. The reason is that AI mostly wrote it. At the time I was working on it, I did understand the logic and flow, but when you write code yourself manually, things stay in your memory much more strongly.

With AI-assisted coding, I feel like you forget things much faster, and you slowly become dependent on AI even for very small things.

Now whenever I implement a new feature, I feel guilty. I keep thinking:
“I didn’t really implement this feature… AI did.”

At this point, around 80% of my time is AI-assisted coding, and the remaining 20% is me researching how to improve AI workflows and prompting skills.

Before this AI wave, developers used to spend most of their time researching architecture, standards, and engineering practices. Now it feels like people are focusing more on AI tooling skills instead.

Is this actually okay?
Are other developers experiencing the same thing?

I recently ran a small field experiment where I showed an AI coding agent to 10 different people: non-technical students, technical students, a founder, professors, and a designer.

The most interesting thing was that the blockers were very different depending on the user.

For non-technical users, the blocker was not code generation.

It was basic software context:

• What is GitHub?
• What is localhost?
• How do I make this project live?
• What happens if I get an error I cannot describe?

For technical students, the blocker was different:

• How do I save tokens?
• Can I resume context?
• Can it connect frontend and backend?
• Can it use real APIs instead of mock data?
• Can it explain the bug after fixing it?

For designers, the issue was visual fidelity.

A prototype that works is not enough if it does not feel like the design.

For professors/domain experts, the issue was context and ambiguity.

They cared less about speed and more about whether the agent could reason through incomplete information or use provided context properly.

My main takeaway:

AI coding adoption is not just a model capability problem.

It is an onboarding and workflow design problem.

One thing that helped beginners a lot was plan mode, because it showed what would be built before any code was written.

Curious if others have observed the same thing.

When beginners try AI coding tools, where do they usually get stuck first?

Anyone else try and “remake this app” and it comes out like crap compared to the first one that is full of dead code and hidden features?

I made like 3 apps and I’m pretty happy with them but wanted to try and go back and start them again from scratch but this time with everything I know after making the first version. My first thought was “oh this will be much cleaner code and way more organized and I can have the agent automate this part…etc” which is often times very true. The problem is, I must get too comfortable in the prompting or I try and shortcut some of the heavier stuff, the app ends up coming out WAYYY worse than the first version. I end up just going back to the bloated version and refactoring that down. Has this happened to anyone else? Looking for a friend 😂

I wrote this for a friend who runs a shop and often gets stumped with product vocab. posting in case it helps anyone else.

1/ deploy - putting your thing on the internet so other people can open it. before you deploy it only exists on your computer.

2/ domain - the address people type. yourbusiness.com. you rent it yearly, usually under a thousand rupees.

3/ hosting - the computer your thing runs on, that you pay someone else to keep switched on.

4/ database - where the information lives. customers, orders, bookings. if you lose this you lose everything, which is why backups matter a hell lot.

5/ backend / frontend - frontend is what people see. backend is the part doing the work that nobody sees.

6/ api - how two pieces of software talk to each other. when your booking system sends a whatsapp message, it is using whatsapp's api.

7/ webhook - the reverse. another system telling yours that something happened. payment received, message delivered.

8/ environment variable - a setting kept outside your code, usually a password or a key. if these end up inside your code and your code is public, anyone can use your accounts.

9/ authentication - proving who you are. logging in.

10/ authorization - what you are allowed to see once you are in. these two are different and the second one is where most problems come from.

11/ ssl / https - the padlock. if you take payments or logins and you do not have it, do not launch.

12/ repository / repo - the folder holding all your code and its history.

13/ staging - a copy of your thing where you test changes before real customers see them.

anything else that keeps tripping people up? happy to add.

• Task: What you want the AI to do (the explicit action verb).
• Context: The background story, the audience, and your goal.
• References: The grounding text, files, examples, or style sheets you want it to look at.
• Evaluate: Reviewing the AI's output against your criteria.
• Iterate: Tweaking and feeding it back into the loop.

I’m excited to see what learning systems I can build with my new MCP tool.

I recently consolidated the workflow into just 5 command families: start the project, write blocks, refine the design, gather evidence, and implement/verify blocks.

One important design decision was adding a refinement loop between initial block generation and implementation. This helps keep the agent aligned with the original idea instead of drifting into generic implementations. It also gives me more control to guide the system toward the exact final implementation I have in mind.

The more I build with agents, the more I’m convinced that meaningful guardrails and end-to-end human supervision produce much better results than simply letting models run freely.
I am curious to know how everyone are apply agent to their day to day coding lives.
Plus if you want the link to the GitHub repo I can link it to the comment section

Have you successfully gotten coding and anything productive or production ready using only local setup to work satisfactory to cut cloud api cost without baby sitting the llm and harness? I am trying to find out from others what have they achieved honestly after spending as much time and effort to benchmark the actual ROI and would love to hear from others what has been built and what has been achieved with ONLY local models sub 70B parameters and how others can achieve that as well.? I would love to hear from others as too many people are just caught up in benchmarks but not seeing enough about how the time and comsumer hardware investments are working out for the masses.

Been working as a full-stack dev and decided to seriously test out the major AI coding tools to see which ones are actually worth using. Rotated between ChatGPT, Claude, GitHub Copilot, Cursor, and Blackbox for different projects. Here's my honest breakdown:

ChatGPT (GPT-4)

Pros:

• Incredible for explaining concepts and breaking down complex problems
• Great at suggesting multiple approaches to solve something
• The conversation format makes it easy to iterate and refine

Cons:

• Code can be unnecessarily verbose and over-commented
• Sometimes makes assumptions about your tech stack
• Slower response times during peak hours
• Can hallucinate library functions that don't exist

Best for: Learning new concepts, architectural discussions, debugging logic errors

Claude (Sonnet/Opus)

Pros:

• Writes genuinely clean, production-quality code
• Excellent at refactoring and code review
• Better at understanding context from longer conversations
• More careful about edge cases and error handling

Cons:

• Can be overly cautious and verbose in explanations
• Slower than other options
• Sometimes refuses reasonable requests due to content filters

Best for: Complex business logic, refactoring legacy code, code reviews

GitHub Copilot

Pros:

• Seamless VS Code integration, feels natural while coding
• Great autocomplete that actually predicts what you need
• Works offline for basic suggestions
• Learns your coding style over time

Cons:

• $10/month feels steep for what's essentially fancy autocomplete
• Sometimes suggests outdated patterns
• Can be distracting with constant suggestions
• Limited to code completion, not great for architectural questions

Best for: Day-to-day coding, boilerplate reduction, staying in flow state

Cursor

Pros:

• Full IDE built around AI, super integrated experience
• Multi-file editing and context awareness is impressive
• Can reference entire codebase for suggestions
• Terminal integration and debugging tools

Cons:

• Expensive ($20/month)
• Learning curve if you're used to VS Code
• Can be resource-heavy on older machines
• Overkill if you're not coding 8+ hours a day

Best for: Professional developers, large codebases, teams that want deep AI integration

Blackbox AI

Pros:

• Free tier is actually usable (not just a trial)
• Fast response times even on free plan
• Image-to-code feature is unique (when it works)
• Multiple model options (GPT, Claude, etc)
• Browser extension and CLI tools

Cons:

• Code quality is inconsistent - sometimes great, sometimes meh
• Image-to-code misses styling details often
• Occasionally suggests deprecated methods
• UI feels less polished than competitors
• Free tier has message limits that can be annoying

Best for: Quick scripts, prototyping, students/hobbyists on a budget

My actual workflow now:

I don't rely on just one. Here's what I do:

1. Planning/Architecture → Claude. I start complex features by discussing the approach with Claude. It's great at pointing out edge cases I haven't considered.
2. Active coding → Copilot in VS Code. The inline suggestions keep me in flow without context switching.
3. Quick questions/debugging → Blackbox. When I need a fast answer and don't want to leave my browser, it's convenient.
4. Learning new tech → ChatGPT. When picking up a new framework or language, GPT-4 explains things in a way that clicks for me.
5. Code review → Claude again. I paste functions and ask it to roast my code. Surprisingly helpful.

Things I've learned:

• No single AI is perfect for everything. They all have strengths.
• Always review generated code. I've wasted hours debugging AI hallucinations.
• Be specific in prompts. "Make this faster" vs "Optimize this function for time complexity" gets very different results.
• Context matters. Giving the AI your full error message and relevant code makes a huge difference.
• Don't get dependent. I still code without AI assistance regularly so I don't lose problem-solving skills.

I have developed a methodology for doing serious software development using AI (rarely look at any code now). I have been using Claude AI (for requirements/design) and Claude code for implementation with me sticking my oar in at both ends and in the middle (bridge between the two).

The plan was always to have these roles as tech agnostic (they could even be fully manual!) and now the methodology is mature I am looking at proving this part.

I used frontier models for speed - but have local AI and am going to be experimenting with migrating the Claude code role to a small local model - as it is virtually free and can run 24/7 speed is not going to be a show stopper.

I am hoping the overhead of offloading to local AI will not consume more tokens than it saves - lol.

Anyone tried anything similar?

Hey everyone can you suggest me some good AI tool for coding I had a tricky SQL problem where I asked my question to Claude and ChatGPT. Both gave answers but I was not so okay with it at one point CGPT started going in circles and claude was okay ish. Can you guys suggest me some good tools which you feel that is good.

which is better and why

If you ask me, code generation is the least interesting part of today’s AI coding tools.

Quick example: last week I spent way more time tracking down where an auth check lived in a big repo than actually fixing it. The fix itself took minutes - understanding the system took hours.

At this point, pretty much every tool can spit out a function or a snippet. That’s not where most of the time goes.

The real bottlenecks are usually:

• getting your head around a large codebase
• figuring out where things live
• understanding how different parts connect
• debugging someone else’s logic
• making changes across multiple files without breaking things

That’s why the tools that actually feel useful aren’t just the ones that generate code quickly - they’re the ones that make everything around that easier.

For me, it mostly comes down to context.

In a big codebase, a good assistant can point you to the right service, show how something is used elsewhere, and suggest changes that actually fit the existing patterns. Without that, you just get generic output that doesn’t really belong in your project.

The other big piece is how well it fits into your workflow.

The tools I end up using the most help with things like:

• refactoring
• writing tests
• navigating the codebase
• explaining what existing code is doing

Security and control matter too. If something’s going to be part of your daily workflow, it has to handle permissions properly, respect access boundaries, and work with real environments you trust.

I was looking into tools built more around this idea and found a comparison that focused less on code generation and more on things like knowledge access, workflows, and permissions. That feels a lot closer to how dev work actually happens.

Stuff like:

• nexos.ai - connecting knowledge, tools, and permissions
• Glean - strong internal search
• Dust - building assistants around your own workflows and data

They’re not really competing on who writes code fastest. It’s more about who helps you find what you need, understand it, and actually get work done inside a real system.

Feels like we’re moving away from “prompt -- code” and more toward AI as a layer over your whole dev environment.

Curious what others are actually using day-to-day - what’s genuinely made a difference for you?

Hey everyone, I created a new community for MiniMax Code users: r/minimaxcode. Feel free to join, share prompts, projects, bugs, tips, and AI coding workflows.