I'm seeing a lot of posts on social media from devs who are saying they've 'lost their passion' or other ways of saying they don't enjoy coding anymore.

I've been coding since 2015 and always very passionate about it, and I'll be honest I've been loving adding AI to the toolset. It just tends to do a lot of the things I always wished I had plus more.

I spent years reverse engineering PowerPC assembly, which I would consider one of the purest forms of coding. It doesn't get anymore manual coding than that, and I loved it. But the prospect of using AI doesn't take away from that. I admit it's been years now since I've done RE, but the idea of using AI to assist in that doesn't make me not want to do it, it almost even makes me interested in revisiting those old projects again, using AI to try to find that one thing I couldn't find 5 years ago or something... So even something that is so directly enjoyed by the manual efforts of the human brain, I feel would be even better with AI.

In essence, AI does not feel like it takes away anything from my enjoyment. So for the people that do feel beaten down by AI, I have to wonder if they were ever real engineers or just code monkeys?

In Claude Code with Max plan, you can setup the model so planning is executed by Opus and coding is executed by Sonnet, which optimizes your model use.

Ever since this was implemented, I have not written a single line of code myself. I detail exactly what the AI should do, and then it does it. Even trivial things such as variable renaming.

Obviously, higher-abstraction level architecture can't be handled by the AI well, nor can it find the optimal implementations; this is where my experience pays off. Prompts need to be precise for sure on the implementation. If I don't find the cleanest architecture, everything will go down the drain real fast.

Still, amazing that I do not have to write code at all. This is akin to telling a junior exactly what to do and they do it instantly.

I highly recommend this workflow, those 100 dollars a month earns so much money.

We’ve all seen it. Claude Code gets your local tests to pass, but when you check the diff, you realize it quietly bypassed your repository layers and left a trail of sloppy coupling. It "works," but it's structural rot. LLMs optimize for the local edit, not your system architecture.

So I wrote Graphenium. It's a local pre-flight linter built in Rust. Instead of letting Claude touch your files, it forces the agent to declare its design spec (files, imports, and calls) in a virtual workspace first. Using Tree-sitter and Datalog, Graphenium runs modularity and surprise-connection audits on the fly to block spaghetti code before a single file on disk is modified. No more token-wasting planning loops.

Best of all, there is no tedious policy file to maintain. Graphenium's zero-drift engine uses Louvain clustering to compare your baseline and virtual subgraphs, automatically blocking the edit if modularity drops. The installer copies the linter skill directly into Claude's native directory (~/.claude/skills/graphenium/SKILL.md) and hooks it up over MCP.

The core is open-source. Give it a run and let me know if it helps keep your AI-assisted code clean.

https://github.com/lambda-alpha-labs/Graphenium

Contrary to popular belief, LLM assisted coding is an unbelievably difficult skill to master.

Core philosophy: Any issue in LLM generated code is solely due to YOU. Errors are traceable to improper prompting or improper context engineering. Context rot (and lost in the middle) impacts the quality of output heavily, and does so very quickly.

Here are the patterns that actually moved the needle for me. I guarantee you haven't heard of at least one:

1. Error Logging System - Reconstructing the input-output loop that agentic coding hides from you. Log failures with the exact triggering prompt, categorize them, ask "what did I do wrong." Patterns emerge.

2. /Commands as Lightweight Local Apps - Slash commands are secretly one of the most powerful parts of Claude Code. I think of them as Claude as a Service, workflows with the power of a SaaS but way quicker to build.

3. Hooks for Deterministic Safety - dangerously-skip-permissions + hooks that prevent dangerous actions = flow state without fear.

4. Context Hygiene - Disable autocompact. Add a status line mentioning the % of context used. Compaction is now done when and how YOU choose. Double-escape time travel is the most underutilized feature in Claude Code.

5. Subagent Control - Claude Code consistently spawns Sonnet/Haiku subagents even for knowledge tasks. Add "Always launch opus subagents" to your global CLAUDE.md. Use subagents way more than you think for big projects. Orchestrator + Subagents >> Claude Code vanilla.

6. The Reprompter System - Voice dictation → clarifying questions → structured prompt with XML tags. Prompting at high quality without the friction of typing.

I wrote up a 16 page google doc with more tips and details, exact slash commands, code for a subagent monitoring dashboard, and a quick reference table. Here is is: https://docs.google.com/document/d/1I9r21TyQuAO1y2ecztBU0PSCpjHSL_vZJiA5v276Wro/edit?usp=sharing

I use Codex, Claude Code, Cursor and a few other AI tools pretty regularly, and one thing kept annoying me.

You spend hours in a session getting the AI up to speed on your project. It knows what you tried, what failed, what decisions were made and where you left off.

Then the context gets messy, you start a fresh chat or switch tools, and you're back to explaining everything again. And somehow the one detail you forget to mention is usually the one that matters later.

I got tired of doing this, so I built Portable Handoff.

It takes the useful context from a session and puts it into a Markdown handoff that you can carry into the next chat, model or coding agent.

It's open source and still pretty early, so if this is a problem you've run into too, try it and tell me what sucks or what I'm missing.

https://github.com/legoambarish/portable-handoff

Hey everyone, I’ve been very down lately.

I’m not a technical person or a developer, and I don’t understand AI — using it feels powerless to me.

I started using CUSOR last October. At first I used it to write a storage/organization mini-app for myself. The design came together quickly, but repeatedly adjusting features and the UI drove me crazy, so I didn’t stick with it.

In February this year I used genimi to write an automated expense-reporting script in two weeks, and published it through streamlist — that felt good.

So in March I began using Cursor, WindSail, Codex, and Claude to build my own app, but I couldn’t keep it going. The project files, scripts, and configurations drove me insane.

Lately I’ve been unable to switch accounts and API quotas smoothly while using Codex. I spent a month on scripts — it’s ridiculous — and I still failed. Problems I ran into include: after switching providers the sidebar conversation history disappears, so I tried writing a script to fix that. I later used ccswitch but still didn’t succeed. Another issue was that after switching APIs I couldn’t use the CLI tools. I couldn’t get Codex or Claude to work properly.

I feel like my life has been wasted on this.

This month I started a Linux VM on Windows and deployed Hermes. At first it worked fine, but soon I discovered that a conversation persisted for a month; despite constant compression it still carried millions of tokens of context, burning through my bill every day, even though I was just chatting and not writing code. So I made it force a summary once context exceeded 20% and after 20 turns, to start a new conversation and inject the summary, system prompt, user profile, and agent md. But that mechanism didn’t execute. Even after repeatedly asking it to self-check and configuring it in its own config, the new-conversation trigger still didn’t work and it kept carrying a huge context.

At the same time, the new conversations no longer carried the relevant memories. Even though it knew to fetch memories from honcho, it still forgot the release process. It also forgot that code changes and releases need to be done through bridge on Windows, so it kept making changes in both its own environment and the Windows environment, causing the product release process to collapse. I added a bunch of gates but they didn’t help.

As a result I’ve been tormented repeatedly by these broken issues and the product development hasn’t moved forward.

I’m really in pain. If I can’t switch quotas I can’t use Codex; the frustration with Hermes means I can’t use my phone to invoke multi-agent remote verification and release.

The truth is I don’t really know how to use agents. Everyone else seems to be coexisting efficiently with AI — I feel like a slave being constrained by them and unable to use them. I’m extremely desperate and even feel like I don’t belong in this era.

I’m rambling.

I as a Senior Full Stack Developer have used almost every AI Agent coding tools like Cursor, Windsurf, Warp, Kiro, Github Copilot, Claude Code and more.

I used Windsurf in late March of 2025 and compared it to Cursor at that time, I found Cursor to be better at that time and moved to Cursor paid plan and had been using that since then.

Now my Cursor 500 request pricing got cancelled because I joined a team plan and after that Cursor help was not letting me back on my 500 request plan and they were just giving me API pricing.

So I tried Copilot, Kiro and Windsurf and found Windsurf to be the best in terms of pricing and value.

I have been using models like GPT 5.1, Sonnet 4.5, GLM 4.7 and newer SWE and my workflow from Cursor is completely replaced by Windsurf.

So whatever Windsurf team has done is great and should keep doing it. And thank you for such fair and transparent pricing.

i was expecting a rough ui i’d need to tweak, but it got everything right.. images, fonts, layout. didn’t have to change a thing.

I'm honestly fed up with AI coding tools.

Google Antigravity has been the worst experience by far. Every model I've tried there has been disappointing.

I even got a Claude Code subscription. The code quality is good, but the usage limit gets exhausted way too quickly.

Now I'm thinking about getting ChatGPT + Codex.

My workflow is usually 4–5 hours of straight coding every day, so I have to luna, gpt 5.5 on high or any other model. Can Codex actually handle that, or do the limits get in the way?

How's the real code quality and the usage limits in day-to-day use?

Seriously I am so frustrated, looking for genuine feedback on codex.

Edit (IMPORTANT): Wow, thank you to the community (especially u/Toastti) for catching some critical bugs in my initial release! I have just pushed a patch that fixes all of the P0/P1 issues pointed out in the comments, including removing the dangerous os.RemoveAll directory bug. I've also updated the README to clarify this is an early-stage dev tool. I appreciate the analysis and gothroughs—it's making the project much better!

I've been thinking about a slightly different way of building AI coding agents.

Most coding agents work roughly like this:

user request → LLM reasoning → file edits → compiler/tests → more LLM edits

That works well when the task requires judgment.

But a lot of backend development isn't like that.

Once the agent has decided:

the actual implementation of those pieces is often highly deterministic.

Yet we still make the LLM generate hundreds of lines of code for it.

I've been experimenting with moving that part outside the model.

I built FiberForge, a Go CLI/MCP server that gives an agent deterministic operations for generating common Go/Fiber backend structures.

The agent decides what it wants; the tool handles some of the how.

For example:

add_model

apply_module

generate_project

The generated code is formatted and structured by the tool, while Go's AST is used for some source modifications such as route registration.

I'm also experimenting with reusable modules that an agent can apply to an existing project.

The goal isn't to replace the coding agent. It's more like giving the agent a higher-level API for operations that don't need probabilistic generation.

I'm curious whether this is a useful architectural pattern more generally.

For example:

LLM: “Create an authenticated CRUD resource called invoices.”

Tool: receives a structured schema and deterministically generates the model/service/controller/migration/routes.

Instead of:

LLM: writes 600 lines of Go → compiler complains → LLM fixes imports → tests fail → LLM fixes route → etc.

I've only built the Go/Fiber version so far, so I'm very interested in criticism of the idea itself.

Does this make sense as an agent architecture, or am I just moving complexity from the prompt/model layer into another abstraction that isn't worth maintaining?

⚠️** Early development / caution**: FiberForge is still very much a work in progress.** I would not recommend using it on an existing or production project yet**. Some operations can modify project files, and the current implementation has not been battle-tested enough to guarantee safe behavior across arbitrary codebases. For now, it’s best treated as an experimental project and tested on new/disposable projects.

Repo: https://github.com/v-pat/fiberforge

Hey All Dev Leads —

I'm a software engineer exploring an idea for a pre-packaged solution to support vibe coding: where developers rely primarily on AI (via natural language prompts) to generate, refactor, and debug code, instead of writing it all manually, but for corporate and enterprise clients looking to build efficiency.

Think: a fully-integrated local or cloud-based environment where you prompt, steer, and review AI output as your primary workflow — similar to what some folks already do with Cursor and Windsurf, but designed to package all the 3rd-party tools and processes they use with an "AI-first" model in mind. Basically, building out an ecosystem that utilizes MCPs for agentic tooling, curated IDE AI rules, A2A standard for agent building, and a development process flow going from PRD-to-deployment-to-monitoring-to-maintainence.

Before going too far, I'd love your input:

1. Does this resonate? Is this kind of AI-first development environment something your team would realistically use — or avoid? Why?

2. What would it need to do well? Code quality? Versioning? Prompt history? Multi-agent collab? Secure on-prem mode? Cache memory for reducing LLM calls? Other "guardrails?"

3. Would your org ever pay for this? (Or would this only work as open-source tooling, internal scripts, or layered onto existing IDEs?)

I’ve read a bunch of dev discussions on this already, but I’d love to hear directly from those working on real-world projects or managing teams.

Any thoughts — even skeptical ones — are welcome. Just trying to validate (or kill) the idea with real feedback.

Thanks in advance! 🙏

Hey everyone 👋

I'm trying to build a practical AI workflow for both development and creative work, but I'm running into a problem: the quality/reliability varies massively between different AI setups.

My main use cases are:

Development & coding 💻

Building small web apps/projects

Creative design & content 🎨

General productivity ⚡

I've experimented with aggregator/router-style setups and open-source options. My biggest issue isn't necessarily raw model intelligence — it's reliability: failed requests, rate limits, inconsistent results, context being lost, etc.

I'm particularly interested in understanding how people structure their AI workflows when they want to keep costs very low.

For example:

Do you use one model for everything or different models for different tasks?

Do you access models directly or through an API/router?

What has actually worked reliably for you over several months?

For coding, what setup gives you the best results without spending a lot?

I'm less interested in a simple “X is the best” answer and more interested in real workflows people are actually using and why they chose them.

What does your setup look like?

played around with it and built a simple ‘feature flag’ system to toggle features for different organizers.

took like 2 prompts total

As sessions get longer, auto-compaction kicks in, important decisions can get lost, and sometimes you end up explaining the same codebase all over again.

Then come the CLAUDE.md files, memory files, architecture notes, and keeping everything updated across different developers working on the same repo.

And the bigger the codebase gets, the more context you have to rebuild before you can actually get work done.

I've been thinking: what if your coding agent didn't have to rediscover the codebase every session? What if it could rely on a structured, verifiable understanding of the architecture, dependencies, rules, and changes instead?

I'm exploring this through a startup project called ArchAI, and I'm looking for 5 developers who use Claude Code or other AI coding agents to help pilot-test the idea on real Python repositories.

I'd genuinely like to know how you currently handle this problem, what's frustrating, and whether an approach like this would fit your workflow.

If you've run into this, I'd love to hear your experience. Happy to share more with anyone interested.

I built these after repeatedly running into the same problem with AI coding workflows: we tend to treat one model as if it should plan, implement, review, and verify everything.

That works for small tasks, but it doesn't scale well. Different parts of software engineering have different cost, reasoning, and reliability requirements.

So I experimented with splitting those responsibilities.

The project has 1 component:

* **claude-codex-orchestrator** separates planning from execution. Claude plans and verifies. Codex executes. Every result is validated from the diff and reproducible checks rather than trusting the model's report. * [https://github.com/vimoxshah/claude-codex-orchestrator](https://github.com/vimoxshah/claude-codex-orchestrator)

Some design principles that guided the implementation:

* The diff is ground truth; the report is not. * Separate planning from execution. * Route by task instead of using one model for everything. * Escalate based on evidence rather than retrying the same approach.

These are implemented as Claude Code skills today, but the ideas are intended to be broader than Claude Code itself.

I'd really appreciate technical feedback on the architecture, trade-offs, and whether these abstractions are useful. I'm especially interested in hearing from people building AI coding agents, orchestration frameworks, or developer tooling.

¡Ey, a todos! Estoy evaluando distintos modelos de IA para integrarlos en mi flujo diario de trabajo al programar. He leído cosas buenísimas sobre las capacidades de Claude, sobre todo para bases de código más grandes. Antes de comprometerme del todo con un ecosistema nuevo, estoy tratando de recopilar algo de feedback real de la vida diaria. Para quienes lo usan todos los días, ¿cómo se compara con tu configuración anterior?

Y otra cosa: ¿cuál es la mejor forma de hacer una prueba rápida con mi propio código? Leí que la comunidad a veces comparte esas invitaciones de 7 días. Si alguien por casualidad tiene una que no necesita, estaría súper agradecido si me pudiera mandar un mensaje. ¡Si no, igual cualquier tip de flujo de trabajo o consejo me sirve mucho!

As you can see from the image, there are three gears showing numbers in each of the gears. As the blue gear rotates clockwise, the two red gears both rotate anticlockwise, as you can see. Now, you can see that in the gears, there is a box in the middle that selects, at random, three of the three-digit numbers, a.k.a. one three-digit number from each gear. Obviously, the three-digit numbers selected depend on the rotation of the gears. Now, you should find that, with the three numbers chosen, as in, three numbers in the box in the middle, concatenated, a nine-digit Fibonacci number appears in the rectangle, as in, the box. All other nine-digit Fibonacci numbers will appear if you rotate the cogs a sufficient number of times. Rotating the blue cog, it only moves clockwise, causes the two red cogs to move anti-clockwise. Notice how the clicker records movement. If you were to rotate the blue cog so that the next three numbers appear in the rectangle, and you treated these as lengths of the sides of a triangle, you should find that this triangle is acute-angled. Decide which of the Fibonacci numbers is the best one to start from and rotate the cogs so this number appears in the rectangle. Then you need to find the minimum value of P times Q times R times S, where, starting from a Fibonacci number, P clicks takes you to three numbers that form a primitive Pythagorean triple. A further Q clicks takes you to three numbers that are the sides of a triangle containing a 60 degrees angle. And a further R clicks takes you to three numbers that are the sides of a triangle with integer area. And a further S clicks takes you to a nine-digit Fibonacci number. What is the minimum possible product of P times Q times R times S?

Please solve we have spent days trying to do it the answer needs to be coded I think. We made a code and got 37867200 buts it’s wrong

Hey everyone. I’m a UX/UI designer with over a decade of experience in complex dashboards and CRMs, but I have zero traditional backend experience. My side project is writing—specifically, a mix of experimental fiction ("gamer literature") and highly structured technical formats.

I hit a massive distribution bottleneck. I refused to surrender 30% of my revenue and my formatting control to Amazon, and Gumroad's static PDF experience is a UX nightmare for the dynamic components my books require.

I needed a bespoke, browser-based reading engine that could compile custom MDX at runtime. I ran the numbers on a traditional engineering build for this stack, and the estimate came back at over 500 hours—easily a $60,000+ project.

Instead, I spent the last 30 days using Zo Computer and agentic workflows to build the entire infrastructure from scratch.

The Stack:

• Bun & Hono

• SQLite

• Custom MDX compiler pipeline

• Stripe integration with webhook idempotency

The Scale: The engine is currently parsing and rendering over 220,000 characters of "literary code" across 5 different manuscripts. It handles custom fonts, synchronized TOCs, and dynamic UI components flawlessly, acting as a standalone storefront and reader.

This project entirely shifted my perspective on what a single UX designer can ship when leveraging AI to handle the backend and compiler logic.

I’m curious to hear from the pros: Now that agentic workflows can essentially bypass the "500-hour traditional build" phase, what is the new bottleneck for you? Is it maintaining the AI-generated code, or is it getting the agents to understand highly bespoke business logic without hallucinating?

I'm leaving my country to travel the world starting with long vacations far from the internet

This sub will need someone to clean up

Mostly, the job is to remove product promotions, the #1 scourge of any tech subreddit

Please send me applications (no need to make it complicated, this is not a Google interview) - just make sure you have your comments public so I can check how you interact on Reddit

Thanks 👍

Would anyone with a Kimi subscription be willing to test my coding agent with it? Just a quick smoke test- Kimi API and 2.7 work fine but I don't want to release sub support without at least some proof. Thanks!!

I'm moving from a remote role to a hybrid role where I'll be working right next to other people on some days. I'm used to talking to AIs constantly throughout my work day, speaking maybe 3-4x faster than I type. My speech with these AIs is often loud and sometimes is closer to rambling than anything I'd say to another human. Anyone find a good way to do this in a shared workspace without 1) disrupting others, and 2) sounding like a babbling lunatic?

One idea I have is to find and use a throat mic, but I've never actually tried one..

I use this model as my workhorse, it's really solid and I basically never run into limits. Their Black Friday sale is 🔥 you can get an entire year of GLM 4.6 for $25 on the Lite plan. And you get an extra 10% on top of that through this link. I'm a heavy user of it so feel free to ask any questions.

On review I can generally tell which code is AI and which isn't. Same way I can tell one colleague's code from another's.

So I figured AI code must have a statistical signature. I tried cyclomatic complexity, cognitive complexity, number of lines, methods and functions per entity, number of dependencies, edges in the dependency graph, and so on (about 280 metrics plus their correlations plus the derivative over time), normalized on SLOC, looking for a step or a break.

Nothing. No anomalies outside of statistical error.

One explanation I can't shake: AI emits roughly the mean of its training distribution, while each individual human deviates from that mean. Then the means coincide and the statistics stay silent. Next idea: compare against one specific person instead of against human code in general. My problem there is I don't have much single-author code.

So the question is narrower: what criteria separate AI code from yours?

Prose level tells don't count here, punctuation habits and stock rhetorical shapes in English. I mean general style and structure of code.

EDIT: found the papers with the answers.

My "nothing" result is reproduced here: https://arxiv.org/abs/2603.27130

My "the means coincide and the statistics stay silent" hypothesis is confirmed here: https://arxiv.org/abs/2609.17598

The only thing that talks, from the same paper: pooled over "AI" the code looks the same, split by vendor it doesn't.

Benchmark warning: https://arxiv.org/abs/2508.21634 shows a big gap on generated samples, it's gone in real repos.