anougaret

thanks couldn't agree more :)

hahaha yeah, even real developers cannot anticipate too well what the direction of a bug is on the first try

yes can be a nice lightweight way to debug with a bit of AI other tools in that space will pbly be higher involvement

usual limits of debuggers = barely usable to debug real scenarios

yeah it is still truly hard and rewarding to do deep, innovative software but everyone is regressing to the mean, rushing to low hanging fruits, and just plugging old A with new B in the hopes it makes them VC money or something

real, quality AI breakthrough in software creation & maintenance will require deep rework of many layers in the software stack, low and high level.

this is pretty cool but ultimately it won't be enough to debug real bugs that are nested deep within business logic or happening because of long chains of events across multiple services/layers of the stack

imo what AI needs to debug is either:

- train with RL to use breakpoints + debugger or to do print debugging, but that'll suck because chains of action are super freaking long and also we know how it goes with AI memory currently, it's not great

- a sort of omniscient debugger always on that can inform the AI of all that the program/services did (sentry-like observability but on steroids). And then the AI would just search within that and find the root cause

none of the two approaches are going to be easy to make happen but imo if we all spend 10+ hours every week debugging that's worth the shot

that's why currently I'm working on approach 2. I made a time travel debugger/observability engine for JS/Python and I'm currently working on plugging it into AI context the most efficiently possible so it debugs even super long sequences of actions in dev & prod hopefully one day

it's super WIP and not self-hostable yet but if you want to check it out: https://ariana.dev/

we don't do the LLM part per say

we instrument your code automatically which is a compiler like approach under the hood, then we aggregate the traces

this allows context engineering the most exhaustive & informative prompt for LLMs to debug with

now if they still fail to debug at least we gave them all they should have needed

valid concerns of course

- we are planning a hosted AI debugging feature that can aggregate multiple traces & code snippets from different related codebases and feed it all into one llm prompt, that benefits a lot from having it all centralized on our servers

- for now the rewriting algorithms are quite unstable, it helps me debug it to have failing code files in sight

- we only store your code for 48hours as I assume it's completely unnecessary to store for longer

- a self hosted ver will be released for users that cannot accept this for valid reasons

I think it really depends a lot on the bubble of programming you spend time in In mine, which is more fullstack web, I rarely meet someone who does. I list a bunch of reasons in the article.

Will def. do a technical write up! Wanted to do a more target approach like you around valid mutations only but I think users want to observe variables not only where they are written but also where they are read, so a low hanging fruit was to wrap all the expressions I could (hundreds of lines of AST queries and tricks per language) with functions/lambdas and some sort of "logging". Of course this is only 4 weeks in the making so there is so much more to do. And as you guessed you probably can't do the targeted approach well in Python and others.

Hey, yeah I know sounds weird. We're experimenting with small custom models <1B params to figure out which part of your code you'd probably not want to instrumentalize the normal way (e.g. logging absolutely everything) and instead in a more tailored way (and what that tailored way is), for instance a python for loop with 10k iterations.

you caught me at the moment of coding this!

Thanks :) Let me know if you use it and get into any trouble

yay :) happy to hear that

very much haha, it seems like a lot of people are realizing the upcoming potential with coding agents using them

Thank you! I feel like with Python we cracked the code rewriting issues very much to a point where Ruby could be supported fast

I just released a JS/TS/Python time travel debugger that overlays variable values on top of vscode. It's just a npm or pip install and VsCode extension so it might be easier to use for you: https://github.com/dedale-dev/ariana I'm also planning to add MCP integration today actually!

Hello everyone :)

I just released for free a tool to help you understand python, rust, JS, TS, go code on GitHub!

How did I end up there? Last summer I was interning at the European Space Agency trying to optimize black holes detection algorithms. And well of course as a software guy with little astronomy knowledge (yes, they did hire me) it was tough to understand astronomy code, and code made by some astrophysicists who were non software-specialists. I was wondering if a better UX for reading code was possible, probably using LLMs. Because it is often a huge pain to understand entire codebases, whether when onboarding in a new company, dealing with legacy/crappy code, code in a new language, debugging messy code with tons of side-effects and global state.. So for the last 4 months I've solo-coded this tool. Still wondering if it should be open-source, but at least felt like I should provide it for free for now (costs me a bit tho).

Hope its useful! Let me know what you'd like to see it do in the future

I still don't understand why no one is making some good UI for exploring dependencies and at least helping a bit with understanding them. Hiding them or making interacting with them tricky for non-coders with CLI tools will never produce the mindset shift we need

I love this, I think there is the same problem with IDEs

would be curious to know what other features you thought about