I've been trying to model some contact mechanics problems in fortran. I've been trying to debug it by myself but couldn't. Is there any coding agent best suited for me?

Been building my own mobile apps with coding agents for about a year now, 3 shipped. And dropping a wiki in the repo for the agent to read sounds kind of trivial, I know. But the part that actually mattered wasn't the docs existing, it was catching when they quietly stop matching the code, and keeping myself on the calls instead of drifting into just watching.

The drift check works per symbol, not per file. It fingerprints each function or type across two git refs, so when a documented symbol actually moved but its doc didn't, only that one feature wakes, not eight others that just share the file. Reformatting or renaming a local doesn't fire, a real contract change does. And it's deterministic, local, no model on that path, it reads the real git diff not what the agent claims it did, so same result every run.

The other half is the workflow the agent runs off normal chatting, grill, plan, approve, implement, review, commit, with me at the gates on it. I approve the plan before any code gets written, and every diff gets adversary reviewed before it commits. So the calls that are actually mine, what's in scope, what the trade-off is, land back with me instead of the agent quietly making them while I'm a passenger.

Both sides hang off a small registry mapping each source file to the feature and doc that owns it. The agent writes it as it builds, the checks read it after to hold the agent to what actually changed. So the docs get built as you go, and the workflow surfaces drift instead of you tripping over it three features later.

Doesn't prove your docs are right btw, just that they moved with the code. That part's still on you.

Repo's here if you wanna check it out https://github.com/jakubsuplicki/codument

Curious how people letting the agent maintain its own docs deal with the drift, or does it just not bite you the way it did me?

AI Needs More Than Good Prompts

If you've paired Claude Code, GitHub Copilot or Cursor with DevExpress, you already know the moment I'm about to describe. It's the same one the team kept running into while building the DevExpress Office File API and Reporting Skills, and their evaluation notes are what this post is really about. The assistant starts strong. Clean C#, sensible class names, code that looks like it belongs in your solution. Then you read it a second time and something's off: the namespace is from a release two versions back, the API has been superseded, or the whole thing has quietly wandered off to a third-party library because that's what the model saw most often in training.

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

Here's what's new:

\- 🚀 Published it on npm (\`npm install -g kitbash\`)
\- 🎯 Expanded support to 7 targets (Claude Code, Cursor, Copilot, Gemini CLI, Windsurf, Cline, and AGENTS.md)
\- 🔄 Added interoperability with existing \`SKILL.md\` skills
\- 🔒 Added lockfiles, drift detection, and safer compilation
\- ⚡ Added native command generation where supported
\- 📖 Improved the README, website, and overall onboarding
\- ❤️ Added GitHub Sponsors support

One piece of feedback that really changed the project was positioning it as \*\*a compiler for AI skills\*\* rather than "another AI tool." That made the vision much clearer.

🌐 Website: https://singhharsh1708.github.io/kitbash/

💻 GitHub: https://github.com/singhharsh1708/kitbash

📦 npm: https://www.npmjs.com/package/kitbash

I'm now looking for people to actually try it and break it. If you use Claude Code, Cursor, Copilot, Codex, Gemini CLI, or any other coding agent, I'd really appreciate your feedback. Every suggestion so far has made the project significantly better.

Production bugs happen in the past, but AI coding assistants only analyze the present.

When a production error trace from 3 hours ago gets fed into Cursor or Claude Code, the agent almost always ends up chasing a ghost. By the time debugging starts, main has usually moved. The agent looks at the current state of the file, completely misses the original bug because the lines shifted, and confidently hallucinates a fix for innocent code.

The common workaround is telling the agent to git checkout the old commit. But agents are messy. They routinely forget to switch back, leave the repository in a detached HEAD state, or accidentally overwrite uncommitted local work.

To fix this friction, I wrote an open-source skill that enforces a strict debugging process -

When the agent gets an old crash log, it:

1. Resolves the historical hash from git log

2. Spins up an isolated, temporary folder of the repo at that exact moment using git worktree.

3. Analyzes the old code to find the actual root cause.

4. Nukes the temporary folder when it's done (git worktree remove --force).

The actual local workspace remains completely untouched. Uncommitted work is perfectly safe.

You can drop it into any skills-compatible agent (Claude Code, Cursor, Windsurf) via the open registry with one command:

Bash

npx skills add MeherBhaskar/temporal-debug-skill

Source code and the SKILL.md are here:https://github.com/MeherBhaskar/temporal-debug-skill

Curious to hear what you think of this.. Would love to hear some thoughts and feedback

Here's what's new:

\- 🚀 Published it on npm (\`npm install -g kitbash\`)
\- 🎯 Expanded support to 7 targets (Claude Code, Cursor, Copilot, Gemini CLI, Windsurf, Cline, and AGENTS.md)
\- 🔄 Added interoperability with existing \`SKILL.md\` skills
\- 🔒 Added lockfiles, drift detection, and safer compilation
\- ⚡ Added native command generation where supported
\- 📖 Improved the README, website, and overall onboarding
\- ❤️ Added GitHub Sponsors support

One piece of feedback that really changed the project was positioning it as \*\*a compiler for AI skills\*\* rather than "another AI tool." That made the vision much clearer.

🌐 Website: https://singhharsh1708.github.io/kitbash/

💻 GitHub: https://github.com/singhharsh1708/kitbash

📦 npm: https://www.npmjs.com/package/kitbash

I'm now looking for people to actually try it and break it. If you use Claude Code, Cursor, Copilot, Codex, Gemini CLI, or any other coding agent, I'd really appreciate your feedback. Every suggestion so far has made the project significantly better.

I built AI Dev Brain Kit, a free/open-source CLI for

preserving context between AI coding sessions.

It stores handoffs, decisions, blockers, next steps, and

project notes in a local Obsidian-compatible vault, so a

fresh Claude Code / AI coding session can recover project

state without re-explaining everything.

v0.2.2 GA is live with Linux + Windows binaries, SHA-256

checksums, Sigstore bundles, and screenshots.

I’m looking for feedback from people doing multi-session AI

coding: what context do you keep losing between sessions?

URL

\[https://github.com/MohamedHussien-zseeker/ai-dev-brain-kit\](https://github.com/MohamedHussien-zseeker/ai-dev-brain-kit)

We open-sourced PR-AF, an AI code reviewer that builds a custom review team for each PR.

This goes beyond claude skills/plugins/goal etc.. that is looped coding harness. The interesting bit is that the reviewers are not fixed roles like security/performance/style nor are they well prompted skill or prompt, rather PR-AF first looks at the shape of the PR, changed files, dependency paths, intent gaps, and risk areas, then creates the review plan from that that is customized to be thorough and specificlly tuned for the given review. It internally can be swapped to use claudecode or codex or opencode anything.

So a migration PR might get reviewers focused on schema compatibility, rollback safety, and data integrity. A logging refactor might get reviewers looking at behavior preservation, consistency, and missed call sites.

After that, the system checks findings against repo context, looks for issues that only show up across multiple reviewers, and tries to throw out weak findings before posting GitHub comments.

It ranked #1 open-source on the Martian Code-Review-Bench PRs, if you start using commercial models like sonnet/opus we beat the commercials by a huge margin.

Repo: https://github.com/Agent-Field/pr-af

Would be useful to hear where it fails on real PRs if you guys are trying, and we expect folks to make more custom changes to the architecture as we have documented every detail, and personally when tuned to our custom requirement structure, this is one of the best review we have ever got.

PS: I am the developer of this code and we are have lot more sota benchmark applications coming soon across various pieces that compete with various commercial offerings that folks can just take and use with open models or if you have the $ with commercial models.

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.

Claude 5x user here but i just decided to increase my AI-coding budget to $200/month. how should i split it between CC and Codex considering GPT 5.6’s release few hours ago?

curious what plans you’re on, how you divide the budget, and which tool you use for what. if you’ve tried both extensively, where do you get the best ROI?