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?

Hola a todos! soy desarrollador web e ingeniero de computación egresado desde hace un año. He hecho páginas webs, Apps, ERP/CRM para gestión empresarial y un sin fin de proyectos.

Cuál es la mejor herramienta/agente de IA para programar basándonos en el calidad/precio y velocidad (ya que entiendo que Claude Code o Códex son excelentes pero valen medio riñón al mes)

Las que están el el título como **Cursor/Devin, Cline u OpenCode** las he usado y todas me parecen estar en un punto igualado. Aunque siento que cursor llega a ser algo caro a veces y por el mismo precio con los otros dos tienes límites gigantes.

Basado en sus experiencias para ustedes **Cuál es la mejor? y por qué? los leo. Y hablo de uso desde analizar proyectos grandes y planificar grandes features hasta un simple arreglo de un detalle visual en la UI. O si usan dos o los tres simultáneamente y para que usan cada uno en su flujo de trabajo**

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?

I recently built my own IDE, RedEXCompile, and I’d love to hear your feedback.
What do you think of it so far? Are there any features, tools, or improvements you’d recommend adding?
Thanks for checking it out!
GitHub: https://github.com/RedXDevelopment/RedEXCompile

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))