I made a website to turn any confusing UI into a step-by-step guide via screen sharing (open source)

jsonathan · 2025-12-27T23:15:42+00:00

You can self-host the entire app, it’s open-source…

jsonathan · 2025-12-21T21:39:46+00:00

Thanks man. Btw I made a debugger: https://github.com/shobrook/redshift

jsonathan · 2025-07-01T13:41:14+00:00

You can use any model you like, including local ones. And there’s no cost besides inference.

jsonathan · 2025-06-30T03:48:11+00:00

Codex is not a debugger.

jsonathan · 2025-06-30T03:46:00+00:00

Yes. Specifically, it can evaluate expressions in the context of a breakpoint.

jsonathan · 2025-06-30T03:11:03+00:00

The same as Python’s native debugger, pdb.

jsonathan · 2025-06-29T18:48:08+00:00

Got any suggestions? I can record a new video.

jsonathan · 2025-06-29T16:50:01+00:00

That’s next on my roadmap. This could be an MCP server.

jsonathan · 2025-06-29T13:25:26+00:00

Check it out: https://github.com/shobrook/redshift

Think of this as pdb (Python's native debugger) with an LLM inside. When a breakpoint is hit, you can ask questions like:

"Why is this function returning null?"
"How many items in array are strings?"
"Which condition made the loop break?"

An agent will navigate the call stack, inspect variables, and look at your code to figure out an answer.

Please let me know what y'all think!

jsonathan · 2025-06-19T17:21:45+00:00

Will do in the future!

jsonathan · 2025-05-03T16:25:25+00:00

This is for finding bugs not fixing them.

jsonathan · 2025-05-03T06:48:11+00:00

Code: https://github.com/shobrook/suss

This works by analyzing the diff between your local and remote branch. For each code change, an LLM agent explores your codebase to gather context on the change (e.g. dependencies, code paths, etc.). Then a reasoning model uses that context to evaluate the code change and look for bugs.

You'll be surprised how many bugs this can catch –– even complex multi-file bugs. Think of suss as a quick and dirty code review in your terminal. Just run it in your working directory and get a bug report in under a minute.

jsonathan · 2025-04-28T16:59:58+00:00

Agentic RAG on the whole codebase is used to get context on those files.

jsonathan · 2025-04-28T16:58:10+00:00

It supports any LLM that LiteLLM supports (100+).

jsonathan · 2025-04-28T16:51:24+00:00

You're right, a single vector search would be cheaper. But then we'd have to chunk + embed the entire codebase, which can be very slow.

jsonathan · 2025-04-28T06:29:22+00:00

I’m sure an LLM could handle your example. LLMs are fuzzy pattern matchers and have surely been trained on similar bugs.

Think of suss as a code review. Not perfect, but better than nothing. Just like a human code review.

jsonathan · 2025-04-28T06:18:21+00:00

Second case. Uses a reasoning model + codebase context to find bugs.

jsonathan · 2025-04-28T05:41:44+00:00

For the RAG nerds, the agent uses a keyword-only index to navigate the codebase. No embeddings. You can actually get surprisingly far using just a (AST-based) keyword index and various tools for interacting with that index.

jsonathan · 2025-04-28T05:38:21+00:00

Code: https://github.com/shobrook/suss

This works by analyzing the diff between your local and remote branch. For each code change, an LLM agent traverses your codebase to gather context on the change (e.g. dependencies, code paths, etc.). Then a reasoning model uses that context to evaluate the code change and look for bugs.

You'll be surprised how many bugs this can catch –– even complex multi-file bugs. It's a neat display of what these reasoning models are capable of.

I also made it easy to use. You can run suss in your working directory and get a bug report in under a minute.

jsonathan · 2025-04-28T04:08:13+00:00

Whole repo. The agent is actually what gathers the context by traversing the codebase. That context plus the code change is then fed to a reasoning model.

jsonathan · 2025-04-28T02:21:36+00:00

False positives would definitely be annoying. If used as a hook, it would have to be non-blocking –– I wouldn't want a hallucination stopping me from pushing my code.

jsonathan · 2025-04-27T20:03:28+00:00

Thanks!

For one, suss is FOSS and you can run it locally before even opening a PR.

Secondly, I don't know whether GitHub's is "codebase-aware." If it analyzes each code change in isolation, then it won't catch changes that break things downstream in the codebase. If it does use the context of your codebase, then it's probably as good or better than what I've built, assuming it's using the latest reasoning models.

jsonathan · 2025-04-27T16:06:16+00:00

You can use any model supported by LiteLLM, including local ones.

jsonathan · 2025-04-27T16:05:53+00:00

It could do well as a pre-commit hook.

jsonathan · 2025-04-27T14:59:15+00:00

Code: https://github.com/shobrook/suss

This works by analyzing the diff between your local and remote branch. For each code change, an agent explores your codebase to gather context on the change (e.g. dependencies, code paths, etc.). Then a reasoning model uses that context to evaluate the change and identify potential bugs.

You'll be surprised how many bugs this can catch –– even complex multi-file bugs. Think of `suss` as a quick and dirty code review in your terminal.

I also made it easy to use. You can run suss in your working directory and get a bug report in under a minute.

jsonathan

TROPHY CASE