https://preview.redd.it/uqfmj9ffpu2h1.png?width=1460&format=png&auto=webp&s=3b8fd841e9a2bc6d409dccd66f3215b86443c9e2

Just checked GitHub's billing preview simulator, currently paying $39/month on Pro+ and happily within my included PRUs. Under the new usage-based billing starting June 1st, the same usage pattern would cost me $942.82/month. That's a 24x increase for identical usage. Base subscription price didn't change but the included credits cover exactly $0 of my actual consumption. Already looking at Cursor and Gemini Code Assist. Anyone else getting numbers like this?

Hey everyone,

Just need to vent for a second and see if anyone else is running into this.

I’ve been using Codex inside GitHub Copilot for a while now, and honestly, it’s great. It does what I ask, stays out of the way, and helps me speed up my workflow. But recently, I decided to try out the standalone GPT Codex extension, thinking it might give me a bit more control or a different interface to work with.

Wow. What an absolute train wreck.

It feels like they wrapped this thing in so many aggressive, hyper-sensitive guardrails that it’s practically useless for actual development. I’ll be in the middle of a project, trying to debug something or refactor an old script, and the extension just throws me under the bus.

Instead of code, half my queries get hit with preachy, patronizing refusals:

• "I can't do this because of security/policy reasons..."

• "I wouldn't recommend doing that, try this completely unrelated..."

It’s incredibly rigid, and you can’t even nudge or prompt-engineer your way past it. It literally kills my momentum mid-flow.

How did the same underlying tech end up so drastically different? Copilot actually lets me work, while the GPT extension feels like coding with a HR manager breathing down my neck.

​

Hey everyone,

Just need to vent for a second and see if anyone else is running into this.

I’ve been using Codex inside GitHub Copilot for a while now, and honestly, it’s great. It does what I ask, stays out of the way, and helps me speed up my workflow. But recently, I decided to try out the standalone GPT Codex extension, thinking it might give me a bit more control or a different interface to work with.

Wow. What an absolute train wreck.

It feels like they wrapped this thing in so many aggressive, hyper-sensitive guardrails that it’s practically useless for actual development. I’ll be in the middle of a project, trying to debug something or refactor an old script, and the extension just throws me under the bus.

Instead of code, half my queries get hit with preachy, patronizing refusals:

- "I can't do this because of security/policy reasons..."

- "I wouldn't recommend doing that, try this completely unrelated..."

It’s incredibly rigid, and you can’t even nudge or prompt-engineer your way past it. It literally kills my momentum mid-flow.

How did the same underlying tech end up so drastically different? Copilot actually lets me work, while the GPT extension feels like coding with a HR manager breathing down my neck.

A while back we had a production issue in an older .NET service where requests started hanging under load and the whole app gradually slowed down.

At first everyone blamed the usual stuff (“legacy codebase”, old framework, technical debt, etc.), but the actual problem ended up being much more boring:

One internal HTTP dependency had no proper timeout configured.

When that dependency slowed down, requests just kept waiting. Retries piled up on top of retries, background jobs kept hammering the same dependency, thread pool usage spiked, queues backed up, and eventually the whole service became unstable.

What surprised me was that we didn’t have to rewrite the system to stabilize it.

Most of the fixes were operational:

• adding outbound timeouts
• reducing retry counts
• adding backoff/jitter
• making some jobs fail instead of retrying forever
• documenting recovery steps so production knowledge wasn’t stuck with one person

Made me realize a lot of “legacy system instability” is sometimes just missing failure boundaries rather than the age of the stack itself.

Curious if other people working on older systems have run into similar failure patterns.

Did a full migration for a client - EC2 to Azure VMs, RDS to Azure SQL, S3 to Blob storage. Live app, real users, couldn't afford extended downtime.

Things that went smoothly: compute, storage, DNS cutover.

Things that bit us:

1. Connection strings - obvious in hindsight but Azure SQL connection string format is different enough to break things silently in some ORMs
2. Environment variable naming conventions - the app had some AWS-specific env var names baked in that weren't documented anywhere
3. Firewall rules - Azure's default inbound rules are more restrictive than expected. Spent 45 minutes on something that should have been a 2-minute check
4. Blob storage URL format - any hardcoded S3 URLs in the codebase had to be hunted down manually

Biggest lesson: do a full grep of your codebase for any hardcoded AWS-specific strings before you start. Saves hours.

Anyone else done this migration? What caught you off guard?

Had a client in a panic. Their .NET app was timing out under load. CPU sitting at 30%. Logs showing nothing obvious. They'd already restarted IIS twice, it "fixed" it temporarily each time.

Classic thread pool starvation.

Here's the pattern:

• Sync-over-async calls were blocking request threads
• Thread pool couldn't spin up new threads fast enough under burst load
• Requests queued > timeouts > users see errors > ops team panics

The CPU looks fine because the threads aren't doing CPU work. They're just sitting there blocked on IO, holding a slot in the thread pool that nobody else can use.

What fixed it:

1. Identified every .Result and .GetAwaiter().GetResult() call in the hot path
2. Made the async chain truly async all the way down
3. Added a timeout + cancellation token so requests that take too long actually stop rather than holding threads indefinitely
4. Added a single log line at thread pool queue depth, never flying blind again

If your production app has "random" slowdowns that recycling the app pool temporarily fixes, this is probably your problem.

Happy to answer questions. I've been dealing with legacy .NET production systems for 20+ years and this pattern shows up more than anything else.

If compute is the bottleneck, why not use distributed GPUs, similar to crypto mining, where individuals contribute spare GPU power to train and run models, and get compensated for it? That could lower costs and reduce dependence on a few large providers.

Right now, it feels like AI followed a familiar path: subsidized access, rapid adoption, then rising prices once people depend on it. Maybe the real opportunity is in building open, community-driven infrastructure instead of relying entirely on centralized services.

Curious if anyone is actively working on this or sees it as viable.

https://preview.redd.it/4xt56v685pyg1.png?width=304&format=png&auto=webp&s=1f92277a12b6ddbecd491a9e959ee269ddfe9cbd

They’ve now added weekly usage limits, which raises serious concerns about the direction this is going. Given that DeepSeek is far more cost-effective, I’ll be switching when my Pro subscription expires in two weeks.

https://preview.redd.it/a6fw81kf5pyg1.png?width=585&format=png&auto=webp&s=7fddb34ea61f1136dabb393534cf1bd9b7aab170

Manifest V3 killed background persistence. Google keeps narrowing what extensions can actually do. The user trust problem is getting worse, people are increasingly afraid to install anything.

I run two extensions and here's what I'm watching:

• Organic discovery through the Chrome store is nearly dead unless you're in a high-volume category
• Users who find you through content convert 3x better than store traffic
• The extensions that are surviving are ones tightly coupled to a specific workflow, not general tools

The model that seems to be working in 2026: extension as the hook, SaaS dashboard as the actual product. The extension does the in-browser action, the value lives in the web app.

Curious if anyone else is seeing the same shift or if you're still getting meaningful store traffic.

I deliver fast and reliable work on:

• .NET / .NET Core / ASP.NET Web API development & fixes
• Backend performance tuning and debugging (memory leaks, slow queries, high CPU, etc.)
• System integrations and automation (C# + Python)
• Legacy .NET maintenance, upgrades, and migrations
• Bug fixes and urgent production issues

Rate: $45/h - price per small-to-medium task (depending on complexity). Larger projects can be milestone-based.

I provide live screen share demo/fix so you can test before paying.

DM me with your specific issue (error logs, screenshots, or project description) and I'll give you a quick assessment + fixed price quote.

Available to start immediately.

Thanks!