vampiregrey

I’m a software engineer who joined a startup early (~10 people) and worked through its growth to ~500 employees. I’m currently working in a large enterprise environment, which has given me experience with scale, process, and long-lived systems - but I prefer early-stage work where ownership and speed matter more.

My work has included: – Custom AI agents, backend and infra-heavy systems – scraping and automation pipelines – AI-based outreach and enrichment pipelines – shipping and operating production systems end to end

I’m looking for an early-stage startup (seed–Series A), ideally working closely with founders and owning systems from zero to one.

Portfolio: https://zerobitflip.com Email: sm@zerobitflip.com

I’m a daily user of Claude Code (Pro subscription) and it’s been my primary tool for the last few months.

Over the past week or so, I’ve noticed:

More shallow reasoning

Ignoring parts of context

More confident-but-wrong answers

Slight regression in structured refactors

This is mostly in real-world coding tasks (mid-size projects, not toy prompts).

Could just be my workload getting more complex — but it feels different.

Has anyone else noticed a shift in quality recently? Or is this just variance + perception bias on my end?

Would love to hear if others are seeing similar patterns (or not).

Last week I ran a small experiment while building a mid-sized Go backend (APIs + some concurrency-heavy logic + a bit of refactoring).

I tested:

- Gemini Pro 3 - Opus 4.6 - GLM-5 - Kimi 2.5

My rough criteria:

- Code correctness (first-pass compile success) - Quality of architectural suggestions - Refactor clarity - Handling of existing code context - Cost per useful output

Surprisingly (at least to me), Kimi 2.5 gave the best cost/performance ratio for this particular workload. It wasn’t always the most “verbose” or polished, but it required the fewest correction loops per dollar spent.

Opus 4.6 felt strong on reasoning-heavy changes, but cost scaled quickly. Gemini Pro 3 was decent but inconsistent in multi-file refactors. GLM-5 was interesting but sometimes hallucinated internal project structures.

This is obviously anecdotal and project-specific.

Curious:

What models are people here using for real-world codebases?

Has anyone benchmarked cost vs correction loops?

Are people optimizing for raw quality or iteration speed per dollar?

Would love to hear other dev experiences, especially from people working in Go or other statically typed backends.

Coming to Rails with ~5 years of professional experience, but new to the Rails way of doing things.

It feels productive and opinionated in a good way.

So far I’m enjoying the conventions and speed, but I’m aware every framework has sharp edges you only discover later.

What are the mistakes that experienced developers still fall into when adopting Rails?

I’m a software engineer who joined a startup early (~10 people) and worked through its growth to ~500 employees.

I’m currently working in a large enterprise environment, which has given me experience with scale, process, and long-lived systems - but I prefer early-stage work where ownership and speed matter more.

My work has included: – backend and infra-heavy systems – scraping and automation pipelines – AI-based outreach and enrichment pipelines – shipping and operating production systems end to end

I’m looking for an early-stage startup (seed–Series A), ideally working closely with founders and owning systems from zero to one.

Portfolio: https://zerobitflip.com Email: shubham.maurya.co@outlook.com

Recently, I started looking for a self-hosted drip emailing solution for my Saas, where, based on user actions/intent, I would be assigning them email campaigns. To my surprise, there isn't a single solution that checks all the boxes.

- A good interface - Recording user events - Good Dx/Ux experience

Mautic was the one solution that somewhat fulfils all my requirements and for now I will be going with it. But still, the user experience is far from good.

Any thoughts/Suggestions?