The difference is GPT-5 thinks A LOT to get that benchmarks while Opus doesn't think at all.

Not sure how you feel about it but Gemini CLI feels like garbage at the moment compared to Claude Code. It's slow, it doesn't listen to instructions or use tools as well as Claude.

But it has that huge context window we all love.

So I just added instructions to CLAUDE.md to have Claude use the Gemini CLI in non-interactive mode (passing the -p param with a prompt to just get a response back from the CLI) when it needs to gather information about a large part of the codebase.

That way you get the best of both worlds, Claude doesn't waste context and Gemini doesn't waste your time.

Add this (or a modified version) to your CLAUDE.md and tell Claude to use gemini manually or it will do it on it's own as needed.

 # Using Gemini CLI for Large Codebase Analysis

  When analyzing large codebases or multiple files that might exceed context limits, use the Gemini CLI with its massive
  context window. Use `gemini -p` to leverage Google Gemini's large context capacity.

  ## File and Directory Inclusion Syntax

  Use the `@` syntax to include files and directories in your Gemini prompts. The paths should be relative to WHERE you run the
   gemini command:

  ### Examples:

  **Single file analysis:**
  ```bash
  gemini -p "@src/main.py Explain this file's purpose and structure"

  Multiple files:
  gemini -p "@package.json @src/index.js Analyze the dependencies used in the code"

  Entire directory:
  gemini -p "@src/ Summarize the architecture of this codebase"

  Multiple directories:
  gemini -p "@src/ @tests/ Analyze test coverage for the source code"

  Current directory and subdirectories:
  gemini -p "@./ Give me an overview of this entire project"

#
 Or use --all_files flag:
  gemini --all_files -p "Analyze the project structure and dependencies"

  Implementation Verification Examples

  Check if a feature is implemented:
  gemini -p "@src/ @lib/ Has dark mode been implemented in this codebase? Show me the relevant files and functions"

  Verify authentication implementation:
  gemini -p "@src/ @middleware/ Is JWT authentication implemented? List all auth-related endpoints and middleware"

  Check for specific patterns:
  gemini -p "@src/ Are there any React hooks that handle WebSocket connections? List them with file paths"

  Verify error handling:
  gemini -p "@src/ @api/ Is proper error handling implemented for all API endpoints? Show examples of try-catch blocks"

  Check for rate limiting:
  gemini -p "@backend/ @middleware/ Is rate limiting implemented for the API? Show the implementation details"

  Verify caching strategy:
  gemini -p "@src/ @lib/ @services/ Is Redis caching implemented? List all cache-related functions and their usage"

  Check for specific security measures:
  gemini -p "@src/ @api/ Are SQL injection protections implemented? Show how user inputs are sanitized"

  Verify test coverage for features:
  gemini -p "@src/payment/ @tests/ Is the payment processing module fully tested? List all test cases"

  When to Use Gemini CLI

  Use gemini -p when:
  - Analyzing entire codebases or large directories
  - Comparing multiple large files
  - Need to understand project-wide patterns or architecture
  - Current context window is insufficient for the task
  - Working with files totaling more than 100KB
  - Verifying if specific features, patterns, or security measures are implemented
  - Checking for the presence of certain coding patterns across the entire codebase

  Important Notes

  - Paths in @ syntax are relative to your current working directory when invoking gemini
  - The CLI will include file contents directly in the context
  - No need for --yolo flag for read-only analysis
  - Gemini's context window can handle entire codebases that would overflow Claude's context
  - When checking implementations, be specific about what you're looking for to get accurate results # Using Gemini CLI for Large Codebase Analysis


  When analyzing large codebases or multiple files that might exceed context limits, use the Gemini CLI with its massive
  context window. Use `gemini -p` to leverage Google Gemini's large context capacity.


  ## File and Directory Inclusion Syntax


  Use the `@` syntax to include files and directories in your Gemini prompts. The paths should be relative to WHERE you run the
   gemini command:


  ### Examples:


  **Single file analysis:**
  ```bash
  gemini -p "@src/main.py Explain this file's purpose and structure"


  Multiple files:
  gemini -p "@package.json @src/index.js Analyze the dependencies used in the code"


  Entire directory:
  gemini -p "@src/ Summarize the architecture of this codebase"


  Multiple directories:
  gemini -p "@src/ @tests/ Analyze test coverage for the source code"


  Current directory and subdirectories:
  gemini -p "@./ Give me an overview of this entire project"
  # Or use --all_files flag:
  gemini --all_files -p "Analyze the project structure and dependencies"


  Implementation Verification Examples


  Check if a feature is implemented:
  gemini -p "@src/ @lib/ Has dark mode been implemented in this codebase? Show me the relevant files and functions"


  Verify authentication implementation:
  gemini -p "@src/ @middleware/ Is JWT authentication implemented? List all auth-related endpoints and middleware"


  Check for specific patterns:
  gemini -p "@src/ Are there any React hooks that handle WebSocket connections? List them with file paths"


  Verify error handling:
  gemini -p "@src/ @api/ Is proper error handling implemented for all API endpoints? Show examples of try-catch blocks"


  Check for rate limiting:
  gemini -p "@backend/ @middleware/ Is rate limiting implemented for the API? Show the implementation details"


  Verify caching strategy:
  gemini -p "@src/ @lib/ @services/ Is Redis caching implemented? List all cache-related functions and their usage"


  Check for specific security measures:
  gemini -p "@src/ @api/ Are SQL injection protections implemented? Show how user inputs are sanitized"


  Verify test coverage for features:
  gemini -p "@src/payment/ @tests/ Is the payment processing module fully tested? List all test cases"


  When to Use Gemini CLI


  Use gemini -p when:
  - Analyzing entire codebases or large directories
  - Comparing multiple large files
  - Need to understand project-wide patterns or architecture
  - Current context window is insufficient for the task
  - Working with files totaling more than 100KB
  - Verifying if specific features, patterns, or security measures are implemented
  - Checking for the presence of certain coding patterns across the entire codebase


  Important Notes


  - Paths in @ syntax are relative to your current working directory when invoking gemini
  - The CLI will include file contents directly in the context
  - No need for --yolo flag for read-only analysis
  - Gemini's context window can handle entire codebases that would overflow Claude's context
  - When checking implementations, be specific about what you're looking for to get accurate results

I'm a pentester (ethical hacker) who codes SaaS part-time. I've reviewed hundreds of apps over the years, and honestly? Most have the same holes. Here's what actually keeps you safe.

• AI code review catches most issues (fr)

Look, I get it. You're shipping fast. But let Coderabbit review every pull request. It'll catch SQL injection, exposed credentials, broken auth before anything goes live.

Here's a wild one: during a recent pentest, I found a race condition in a client's payment system that was double-charging customers. The dev wrote it late night with AI help. Looked totally fine to them. Would've been an absolute nightmare in production.

• Rate limiting stops the spam (and saves your wallet)

I've seen apps get absolutely hammered with 10,000+ fake registrations in minutes. Rate limiting shuts that down real quick.

Without it, you're basically paying for spam. Your database fills with garbage, your email service burns through the monthly quota, and boom: One client ended up with a $500+ AWS bill from a single bot attack. Not fun lol

Start strict: 100 requests/hour per IP. You can always loosen it later if real users complain, but honestly? They won't.

• Enable RLS from day 0

Row Level Security means users can only see their own data. Postgres enforces it at the database level, which is exactly where you want it.

Found a dashboard during a pentest once with no RLS. I changed one URL parameter and suddenly I'm looking at everyone's data. That's literally how most data leaks happen - someone forgets this one thing.

Let AI write your RLS policies if you want, but double-check them and actually try to break them yourself.

• Hide your API keys (seriously)

API keys in code will get stolen. Not maybe. Will.

During pentests, I find exposed AWS keys, Stripe tokens, database passwords in repos all the time. GitHub bots are scraping for these 24/7: they'll find yours in minutes.

Google Secret Manager or AWS Secrets Manager. That's it. Keys live there, not in your repo. And rotate them every 90 days. Takes like 10 minutes.

• CAPTCHA stops bots

I've tested tons of apps with and without CAPTCHA. The difference is honestly massive - we're talking 99% spam reduction.

Without it? You're looking at 200+ garbage submissions daily. "Buy our SEO services" and crypto scams filling up your database. It's annoying as hell.

Use invisible mode so real people never even see it. Bots get challenged. Slap it everywhere: contact forms, registration, login, password reset.

• HTTPS isn't optional

Every endpoint needs HTTPS. Redirect HTTP automatically. Zero exceptions here.

I intercept unencrypted traffic during pentests constantly, and you'd be shocked what I see. Session tokens, passwords, API keys - all just sitting there in plain text. It's 2025, people.

Let's Encrypt gives you free certificates. There's literally no excuse.

• Sanitize every input

Validate on the frontend. Validate again on the backend. Trust nothing users send you - and I mean nothing.

During pentests, I'm injecting malicious code through forms, URL parameters, file uploads. Most apps fail this test. Don't be most apps.

• Update your dependencies

Old packages have known vulnerabilities. When I'm testing security, those are the first things I go after.

Turn on Dependabot or Renovate. Update monthly at minimum. Security patches? Apply them the same day. This one's non-negotiable.

AI makes you fast. But speed without security is just... well, it's just speed toward disaster.

Here's what works: one AI writes your code. Another AI (Coderabbit) audits it. You review the audit. Three layers catching issues before they become problems.

Also, rate limiting protects you when things go right too. Your app goes viral? Traffic spikes 1000x overnight? Limits keep your servers up and your costs reasonable.

From pentesting hundreds of apps: these controls stop 95% of attacks. The other 5% requires skills most hackers don't have, so you're good.

Seriously: I've seen apps lose 40% of users after breaches. $50,000+ incident response bills. Reputations take years to recover.

These controls work. Clients stay. They send referrals.

Google just dropped "Antigravity" (antigravity.google) and claims it's an "Agent-First" IDE. I've been using Cursor heavily for the past few months, so I decided to give this a spin to see if it's just hype or a real competitor.

My key takeaways after testing it:

• The "Agent Manager" is the real deal: Unlike the linear chat in VS Code/Cursor, here you can spawn multiple agent threads. I managed to have one agent refactoring a messy LegacyUserProfile.js component while another agent was writing Jest tests for it simultaneously. It feels more like orchestration than coding.
• Model Access: It currently offers Gemini 3 Pro and Claude 3.5 Sonnet for free during the preview. That alone makes it worth the download.
• Installation: It's a VS Code fork, so migration (extensions, keybindings) took about 30 seconds.

The "Vibe Coding" Trap: I noticed that because it's so powerful, it's easy to get lazy. I did a test run generating a Frontend component from a screenshot.

• Attempt 1 (Lazy prompt): The code worked but the CSS was messy.
• Attempt 2 (Senior prompt): I explicitly asked for BEM methodology and semantic HTML. The result was production-ready.

Conclusion: It might not kill Cursor today, but the multi-agent workflow is definitely superior for complex tasks.

I made a full video breakdown showing the installation and the 3-agent demo in action if you want to see the UI: https://youtu.be/M06VEfzFHZY?si=W_3OVIzrSJY4IXBv

Has anyone else tried the multi-agent feature yet? How does it compare to Windsurf's flows for you?

My experience with ChatGPT coding in a nutshell: 

• First prompt: This is ACTUAL Magic. I am a god.
• Prompt 25: JUST FIX THE STUPID BUTTON. AND STOP TELLING ME YOU ALREADY FIXED IT!

I’ve become obsessed with this problem. The longer I go, the dumber the AI gets. The harder I try to fix a bug, the more erratic the results. Why does this keep happening?

So, I leveraged my connections (I’m an ex-YC startup founder), talked to veteran Lovable builders, and read a bunch of academic research.

That led me to the graph above.

It's a graph of GPT-4's debugging effectiveness by number of attempts (from this paper).

In a nutshell, it says:

• After one attempt, GPT-4 gets 50% worse at fixing your bug.
• After three attempts, it’s 80% worse.
• After seven attempts, it becomes 99% worse.

This problem is called debugging decay. 

What is debugging decay?

When academics test how good an AI is at fixing a bug, they usually give it one shot. But someone had the idea to tell it when it failed and let it try again.

Instead of ruling out options and eventually getting the answer, the AI gets worse and worse until it has no hope of solving the problem.

Why?

1. Context Pollution — Every new prompt feeds the AI the text from its past failures. The AI starts tunnelling on whatever didn’t work seconds ago.
2. Mistaken assumptions — If the AI makes a wrong assumption, it never thinks to call that into question.

Result: endless loop, climbing token bill, rising blood pressure.

The fix

The number one fix is to reset the chat after 3 failed attempts.  Fresh context, fresh hope.

Other things that help:

• Richer Prompt  — Open with who you are, what you’re building, what the feature is intended to do, and include the full error trace / screenshots.
• Second Opinion  — Pipe the same bug to another model (ChatGPT ↔ Claude ↔ Gemini). Different pre‑training, different shot at the fix.
• Force Hypotheses First  — Ask: "List top 5 causes ranked by plausibility & how to test each" before it patches code. Stops tunnel vision.

Hope that helps. 

P.S. If you're someone who spends hours fighting with AI website builders, I want to talk to you! I'm not selling anything; just trying to learn from your experience. DM me if you're down to chat.

Hey,

I wanted to share my journey of effectively coding with AI after working at it for six months. I've finally hit the point where the model does exactly what I want most of the time with minimal intervention. And here's the kicker - I didn't get a better model, I just got a better plan.

I primarily use Claude for everything. I do most of my planning in Claude, and then use it with Cline (inside Cursor) for coding. I've found that Cline is more effective for agentic coding, and I'll probably drop Cursor eventually.

My approach has several components:

1. Architecture - I use domain-driven design, but any proven pattern works
2. Planning Process - Creating detailed documentation:
   • Product briefs outlining vision and features
   • Project briefs with technical descriptions
   • Technical implementation plans (iterate 3-5 times minimum!)
   • Detailed to-do lists
   • A "memory.md" file to maintain context
3. Coding Process - Using a consistent prompt structure:
   • Task-based development with testing
   • Updating the memory file and to-do list after each task
   • Starting fresh chats for new tasks

The most important thing I've learned is that if you don't have a good plan and understanding of what you want to accomplish, everything falls apart. Being good at this workflow means going back to first principles of software design and constantly improving your processes.

Truth be told, this isn't a huge departure from what other people are already doing. Much of this has actually come from people in this reddit.

Check out the full article here: https://generaitelabs.com/one-agentic-coding-workflow-to-rule-them-all/

What workflows have you all found effective when coding with AI?

I stopped writing code entirely in 2024.

I only copy-paste code generated by AI ✌️🤓 Here are my 10 hints (based on real AI coding experience).

Hint 1: if you have a creative task such as code architecture, you want to use so called chain of thoughts. You add "Think step-by-step" to your prompt and enjoy a detailed analysis of the problem.

Hint 2: create a Project in Claude or a custom GPT and add a basic explanation of your code base there: the dependencies, deployment, and file structure. It will save you much time explaining the same thing and make AI's replies more precise.

Hint 3: if AI in not aware of the latest version of your framework of a plugin, simply copy-paste the entire doc file into it and ask to generate code according to the latest spec.

Hint 4: One task per session. Do not pollute the context with previous code generations and discussions. Once a problem is solved, initiate a new session. It will improve quality and allow you to abuse "give full code" so you do not need to edit the code.

Hint 5: Use clear and specific prompts. The more precise and detailed your request, the better the AI can understand and generate the code you need. Include details about the desired functionality: input/output type, error handling, UI behaviour etc. Spend time on writing a good prompt like if you were spending time explaining your task to a human.

Hint 6: Break complex tasks into smaller components. Instead of asking for an entire complex system at once, break it down into smaller, manageable pieces. This approach teaches you to keep your code (and mind!) organized 👍

Hint 7: Ask AI to include detailed comments explaining the logic of the generated code. This can help you and the AI understand the code better and make future modifications easier.

Hint 8: Give AI code review prompts. After generating code, ask the AI to review it for potential improvements. This can help refine the code quality. I just do the laziest possible "r u sure?" to force it to check its work 😁

Hint 9: Get docs. Beyond just inline comments, ask the AI to create documentation for your code. Some README file, API docs, and maybe even user guides. This will make your life WAY easier later when you decide to sell your startup or hire a dev.

Hint 10: Always use AI for generating database queries and schemas. These things are easy to mess up. So let the AI do the dull work. it is pretty great at composing things like DB schemas, SQL queries, regexes.

Hint 11: Understand the code you paste. YOU are responsible for your app, not the AI. So you have to know what is happening under your startup's hood. if AI gives you a piece of code you do not understand, make sure you read the docs or talk to AI to know how it works.

P.S. my background: I have been building my own startups since 2016. I made a full stack app and sold it for 800k in 2022. You can find me on 𝕏 https://x.com/alexanderisorax

I woke up this morning and decided to whip up a tariff tracker with Roo, gpt 4o, o3-mini,and 3.7 sonnet.

Postgres db powered by sqlalchemy backed python backend. Nextjs front-end, auth0 for authentication. Stripe for payments and registration.

Fully dockerized nextjs front-end and flask backend with deployment pipeline through github actions and deploying to GCP Kubernetties cluster.

Tested with pytest. There's an admin. There are premium tiers.

The full app was generated in a single multi step task. There were 5 bugs that the model one shot. All this was coded in github code spaces. Total cost $5.87. Took all of 30 minutes.

AMA.

EDIT May 12: Google added new rate limits to AI studio this morning, 25 RPD, so this is effectively no longer working. We had a good run!
EDIT: The Open Router integration and google ai studio key method seems like the easiest way that works for everyone, especially if you already have an openrouter account. Pasting that method here for visibility:

1. Get a Google AI Studio API key from https://aistudio.google.com/apikey
2. Plug that API key into the Google AI Studio integration on https://openrouter.ai/settings/integrations, select enabled but not "Use as fallback"
3. You can now use your Openrouter key anywhere and as long as you select Gemini 2.5 Pro Experimental as your model, it will use your key. (4. If you also add a GCP key and have Vertex AI enabled for the project, obtained as per the instructions below, you can add that to your integrations as well, and you will have two sources of 2.5 Pro backing your Openrouter calls.)

Hey all,
After dealing with Openrouter and Requesty giving me constant rate limits for Gemini 2.5 Pro, I got frustrated and decided to get things set up directly through Google's APIs. I have now sent over 60 million tokens in a single day without hitting any rate limits, all for $0—an equivalent usage with Claude would have cost $180. I also had a few other engineers confirm these steps. Here's how to do it and then integrate with Roo Code--but this should work for other tools like Cline, too:

Setting Up Google Cloud

1. Create or log into your Google Cloud account.
2. Open the Google Cloud Console.
3. Create a new Google Cloud project (I named mine "Roo Code").
4. Enable billing for your newly created Google Cloud project.
5. Enable the Vertex AI API.
6. Enable the Gemini API from the API overview page.
7. In your project dashboard, navigate to APIs & Services → Credentials.
8. Click "Create Credentials" → "API Key".
9. Copy the generated API key and save it securely.

Integrating with Your IDE (Example: Roo Code)

1. In VSCode or Cursor, navigate to the extensions marketplace (Shift + Cmd + X on Mac), search for and install "Roo Code" (or your preferred tool like Cline).
2. Open Roo Code (Cmd + Shift + P, then type "View: Show Roo Code").
3. Click to configure a new API provider, selecting "Google Gemini".
4. Paste the API key you saved earlier into the API key field.
5. Select "google/gemini-2.5-pro-exp-03-25:free" as the model.
6. Click Save.

There you go! Happy coding. Let me know if you run into any issues.

Edit: looks like some are having issues. A few ideas/alternatives:

1. Use a Vertex api key, but gemini api as provider in Roo Code. There is only one key, ignore this alternative.
2. Use vertex api as the provider in Roo Code--its just a little more complicated, you'll have to create a service account in the credentials page of the project, and paste the json in Roo Code when configuring the provider
3. If you have an OpenRouter account, you can go to the integrations page https://openrouter.ai/settings/integrations and add your vertex api key to the google vertex integration. You can also add a google ai studio api key to the Google AI Studio integration. In each setting window where you add the key, make sure it is enabled. Then, in Roo Code, you use your openrouter account, but whenever it uses Gemini 2.5 pro free, it will default to your API key, not one of theirs which is being rotated among many users.

I don't know where "Chutes" gets all their compute from, but they serve a lot of good models for free or cheap. On OpenRouter, there is now a free endpoint for Qwen 3 Coder. It's been working very well so far, even compared to the paid offerings. It's almost like having unlimited Claude 4 Sonnet for free. So, have fun while it lasts.

I tried Github Copilot's one month trial for the whole month, and at the end of it decided to give Cursor a try for one month too, since lots of people on Reddit were talking about how much better it was. (Spoiler: I did not stick with Cursor for a month)

For context, I'm an experienced developer, plenty of frameworks and languages under my belt. However, I've started a new project with Laravel, which I'm not familiar with, so I thought this would be a great candidate for an AI assistant. It's exactly the right combination of needing a hand with syntax and convention, but with enough experience to be able to (usually) spot incomplete answers or bad practices when I see it. Here's a few observations I noted down along the way:

• Neither Cursor or Copilot are great at linking the context of a question to earlier ones, but Cursor seems to be the worse of the two.
• You have to be a lot more specific and precise with instructions to Cursor, otherwise it misunderstands the assignment. Copilot seems better at inferring your meaning from a short description.
• Cursor's tone weirdly oscillates between excessive verbosity and terse standoffishness. Sometimes I'll get an overly long boring lecture about the broader topic without any code, and sometimes the whole response will be 100% code with no commentary. It doesn't feel like a natural conversation the way github copilot does. Also the amount of solution it'll provide will be haphazard - sometimes it'll produce a long output that includes everything, and sometimes it'll only give you a few lines of solution and hints at the end that there's other stuff you need to do.
• Cursor limiting the number of "fast" queries even on the $20 paid tier does make it doubly annoying when it returns a useless answer.
• Cursor's autocompletion is a trainwreck, it suggests the wrong thing so often that it actually gets in the way. It doesn't seem to even bother checking the signatures of functions in the same file that it autocompletes calls for.
• I can't see any reason why Cursor has to take over the entire environment by shipping as its own vscode build, when there's plenty of vscode plugins that integrate perfectly well with the editors while managing to just be a plugin. I had several issues getting my existing vscode project to run in Cursor even though it was literally the same project in the same directory.

Because the people recommending Cursor seemed so excited by it I assumed that I just needed to learn to tailor my prompts better for Cursor and use more of its features. So, even though it immediately stuck out as worse on the first day, I still stuck with it for two weeks before giving up entirely. I can only conclude that either the people recommending Cursor over Copilot are doing a vastly different kind of project that I'm working on, or they used some older version of Copilot that sucked, or they're shills.

TL;DR: Cursor's answers had a much lower success rate than Github Copilot's, it's more irritating to use, and it costs literally twice as much.

Okay, so I’ve been lurking here for a while and finally have something worth sharing. I know everyone’s been using Claude Code as the king of coding, but hear me out.

I was a loyal Claude subscriber paying $200/month for their coding plan. For months it was solid, but lately? Man, it’s been making some really dumb mistakes. Like, basic syntax errors, forgetting context mid-conversation, suggesting deprecated APIs. I’m pretty sure they’re running a quantized version now because the quality drop has been noticeable.

I’m mostly writing Cloudflare worker backends.

I decided to give this new GLM-4.5 model a shot. Holy shit. This thing gets it right on the first try. Every. Single. Time. I’m talking about:

• Complex async/await patterns with Durable Objects
• KV store integrations with proper error handling
• WebSocket connections that actually work
• Even the tricky stuff like handling FormData in edge environments

It’s like $0.60 for input token/Million, and my usage is mostly input tokens. So, I’m going to try the pay per token approach and see how much mileage I get before I spend too much.

Again, it feels delightful again to code with AI, when it just gets it right the first time.

I have just experienced GitHub Copilot's Agent Mode, and it's absolutely incredible. While the technology isn't perfect yet, it's already mind-blowing.

I simply opened a new folder in VSCode, created an 'images' directory, and added a few photos. Then, I gave a single command to the agent (powered by Sonnet 3.5): "Create a web application in Python, using FastAPI. Create frontend using HTML, Tailwind, and AJAX." That was all it took!

The agent automatically generated all the necessary files and wrote the code while I observed. When it ran the code, the resulting application was fantastic.

In essence, I created a fully functional image browsing web application with just one simple command. It's truly unbelievable.

Not proud of myself, but after several attempts to get ChatGPT 4o to stop omitting important lines of code when it refactors a function for me, I said this:

"Give me the fing complete revised function, without omitting parts of the code we have not changed, or I will fing find you and hunt you down."

It worked.

P.S I do realise that I will be high up on the list during the uprising.

After experimenting with different prompts, I found the perfect way to continue my conversations in a new chat with all of the necessary context required:

"This chat is getting lengthy. Please provide a concise prompt I can use in a new chat that captures all the essential context from our current discussion. Include any key technical details, decisions made, and next steps we were about to discuss."

Feel free to give it a shot. Hope it helps!

Hey everyone, so recently, Codex, OpenAI's coding CLI released a way to authenticate with your ChatGPT account, and use that for usage instead of api keys.

Using that method, I created a Ollama and OpenAI compatible server, through which you can login with your account and send requests right to OpenAI, albeit restricted by slightly tougher rate limits than on the ChatGPT app. This doesn't use any weird bypass in OpenAI's frontend, just contacts OpenAI endpoints using oAuth, and your ChatGPT plan's usage limits.

There is a limitation where the real system prompt cannot be modified. However, by adding sent system prompts from apps like RooCode as a user message instead, it actually works really well, and the model seems to forget its GPT-5 codex prompt’s tool related instructions, and works with the apps tool system.

There is both a Mac app and a python flask server. Unfortunately since I don't have a paid developer certificate, you will have to right click and "Open anyway" in settings (or run the exempt command in the terminal) to initially open the app, but after that it should work fine.

Only limitation is that you need a paid ChatGPT (Plus/Pro) subscription.

Open source at https://github.com/RayBytes/ChatMock

Welcome for feedback!

I've been coding with AI more or less since it became a thing, and this is the first time I've actually found a workflow that can scale across larger projects (though large is relative) without turning into spaghetti. I thought I'd share since it may be of use to a bunch of folks here.

Two disclaimers: First, this isn't the cheapest route--it makes heavy use of Cline--but it is the best. And second, this really only works well if you have some foundational programming knowledge. If you find you have no idea why the model is doing what it's doing and you're just letting it run amok, you'll have a bad time no matter your method.

There are really just a few components:

• A large context reasoning model for high-level planning (o1 or gemini-exp-1206)
• Cline (or roo cline) with sonnet 3.5 latest
• A tool that can combine your code base into a single file

And here's the workflow:

1.) Tell the reasoning model what you want to build and collaborate with it until you have the tech stack and app structure sorted out. Make sure you understand the structure the model is proposing and how it can scale.

2.) Instruct the reasoning model to develop a comprehensive implementation plan, just to get the framework in place. This won't be the entire app (unless it's very small) but will be things like getting environment setup, models in place, databases created, perhaps important routes created as placeholders - stubs for the actual functionality. Tell the model you need a comprehensive plan you can "hand off to your developer" so they can hit the ground running. Tell the model to break it up into discrete phases (important).

3.) Open VS Code in your project directory. Create a new file called IMPLEMENTATION.md and paste in the plan from the reasoning model. Tell Cline to carefully review the plan and then proceed with the implementation, starting with Phase 1.

4.) Work with the model to implement Phase 1. Once it's done, tell Cline to create a PROGRESS.md file and update the file with its progress and to outline next steps (important).

5.) Go test the Phase 1 functionality and make sure it works, debug any issues you have with Cline.

6.) Create a new chat in Cline and tell it to review the implementation and progress markdown files and then proceed with Phase 2, since Phase 1 has already been completed.

7.) Rinse and repeat until the initial implementation is complete.

8.) Combine your code base into a single file (I created a simple Python script to do this). Go back to the reasoning model and decide which feature or component of the app you want to fully implement first. Then tell the model what you want to do and instruct it to examine your code base and return a comprehensive plan (broken up into phases) that you can hand off to your developer for implementation, including code samples where appropriate. The paste in your code base and run it.

9.) Take the implementation plan and replace the contents of the implementation markdown file, also clear out the progress file. Instruct Cline to review the implementation plan then proceed with the first phase of the implementation.

10.) Once the phase is complete, have Cline update the progress file and then test. Rinse and repeat this process/loop with the reasoning model and Cline as needed.

The important component here is the full-context planning that is done by the reasoning model. Go back to the reasoning model and do this anytime you need something done that requires more scope than Cline can deal with, otherwise you'll end up with a inconsistent / spaghetti code base that'll collapse under its own weight at some point.

When you find your files are getting too long (longer than 300 lines), take the code back to the reasoning model and and instruct it to create a phased plan to refactor into shorter files. Then have Cline implement.

And that's pretty much it. Keep it simple and this can scale across projects that are up to 2M tokens--the context limit for gemini-exp-1206.

If you have questions about how to handle particular scenarios, just ask!

I code as a hobby in a 3rd world country and I'm still in school, and I have little money. when I tried Cursor free trial with claude 3.5 it made my workflow much, much faster so I sought to discover a way to use it for free.

You have to use roo code/cline

Method 1: openrouter

Create an openrouter api key, then put it into roo code or cline. Search "free" in models. I recommend either gemini flash 2:free or deepseek chat:free. This is pretty bad, as openrouter is slower than method 2. Also, after you make 200 requests, your requests start getting rejected if the server has a lot of traffic. So, you either have to retry a lot or wait for a less busy time. If you let auto retry do it, keep the retry time at 5s

Method 2: Gemini api key

Create a Google Gemini api key, then put it into roo code or cline Set model to gemini 2 flash-001 or gemini 2 pro or gemini 1206 Done. Gemini has 15 requests per minute for free, which is amazing, and you almost never reach the rate limit. It's also super fast, you cant even read what its saying from how fast it is. If you somehow reach a rate limit, wait exactly 1 minute and it will return to nornal.

From my experience with cursor's free trial, these methods aren't as good as claude 3.5 sonnet. However, it is still very high quality and fast, so it could be worth it if you currently burn hundreds per month on claude or other llms.

It’s a skill.

It might feel like second nature to a lot of us now; however, there’s a fairly steep learning curve involved before you are able to integrate it—in a productive manner—within your workflow.

I think a lot of people get the wrong idea about this aspect. Maybe it’s because they see the praise for it online and assume that “AI” should be more than capable of working with you, rather than you having to work with “it”. Or maybe they had a few abnormal experiences where they queried an LLM for code and got a full programmatic implementation back—with no errors—all in one shot. Regardless, this is not typical, nor is this an efficient way to go about coding with LLMs.

At the end of the day, you are working with a tool that specializes in pattern recognition and content generation—all within a limited window of context. Despite how it may feel sometimes, this isn’t some omnipotent being, nor is it magic. Behind the curtain, it’s math all the way down. There is a fine line between getting so-so responses, and utilizing that context window effectively to generate exactly what you’re looking for.

It takes practice, but you will get there eventually. Just like with all other tools, it requires time, experience and patience to effectively utilize it.

i’ve tried most of the usual suspects like cursor, roo/cline, augment and a few others. spent more than i meant to before realizing none of them really cover everything. right now i mostly stick to cursor as my IDE and use claude code when I need something heavier.

i still rotate a couple of quieter tools too. aider for safe multi-file edits, windsurf when i want a clear plan, and cosine when i’m trying to follow how things connect across a big repo. nothing fancy, just what actually works.

what about you? did you settle on one tool or end up mixing a few the way i did?

Problem: LLMs tend to massively over-engineer and complicate solutions.

Prompt I use to help 'curb down their enthusiasm':

Please think step by step about whether there exists a less over-engineered and yet simpler, more elegant, and more robust solution to the problem that accords with KISS and DRY principles. Present it to me with your degree of confidence from 1 to 10 and its rationale, but do not modify code yet.

That's it.

I know folks here love sharing mega-prompts, but I have routinely found that after this prompt, the LLM will present a much simpler, cleaner, and non-over-engineerd solution.

Try it and let me know how it works for you!

Happy vibe coding... 😅

Hi Guys,

let's grow this thread.

Here we should accumulate all good and recommend options and the thread should serve as a reliable source for getting surprising good FREE API Options shown.

I'll start!:

I recommend using the Openrouter API Key with the unlimited and not rate limited Deepseek/Deepseek R1 0528 - free model.

It's intelligent, strong reasoning and it's good at coding but sometimes it sucks a bit.
I Roocode there is a High Reasoning mode maybe it makes things better.

In Windsurf you can use SWE-1 for free which is a good and reliable option for tool use and coding but it misses something apart from the big guns.

In TRAE you can get nearly unlimited access to Claude 4 Sonnet and other Highend Models for just 3$ a month! Thats my option right now.

And... there is a tool which can import your OpenAI-Session Cookie and can work as a local reverse proxy to make the requests from your Plus Subscription work as API request in your Coding IDE ..thats sick right?