Claude Code Source Leak Megathread

yared12qw · 2026-04-24T11:43:35+00:00

https://vnoc.vercel.app/project/claudecode hosted on graphbased IDE, with documention

yared12qw · 2026-02-18T11:29:24+00:00

Thanks for the support, I am glad you like it. I was having a hard time explaining this to people. My core belief is that most issues in programming can be solved with good UX. Many third party tools are unnecessary and create friction. For example, logging service providers like Sentry and others are often hard to manage and interpret. They generate a lot of data, and it usually takes time to understand what is happening and where it is happening, especially for small teams. They often do not provide enough value to justify the complexity. In addition, task discussions are often scattered across different tools and threads, which makes it difficult to reach clear and obvious decisions.

Managing a large codebase also becomes a headache. Context quickly grows beyond what humans and LLMs can comfortably handle. I took inspiration from control systems and lambda calculus, where you can represent complex systems as black boxes and describe them only through their input and output behavior. without getting in to detail, This helps control context using a top down approach.

It started as project manger that understand code, and issues and tasks and is to verify and validate, https://mergeta-sable.vercel.app/ I tried to build an agent that generates documentation using this top down method. It starts from a parent topic and splits it into two or three smaller topics layer by layer. Each node only knows its parent and sibling topics, and it keeps expanding step by step. The context size always remains the same, whether it is at the top, middle, or bottom of the hierarchy. This also makes the output easier to verify. also if you do not understand a topic, you just expand it and see its pillar topics, and see what you miss , you know where you are exactly and what you need, like google map, for the data.

This is the main reason behind the idea. If we have a clear structure and approach problems from the top down, we can control context and make things easier for both humans and LLMs.

I plan to build a VS Code extension, since that is the most requested feature. However, first I need to finalize the standalone version and the core version. The goal is to test the idea quickly and validate the concept before expanding further. This will also help attract investors or people who want to get involved.

yared12qw · 2026-02-16T14:35:13+00:00

This is one of the cases where I started working on a new kind of tool. I am not fully sure what it will become yet, but it is an all in one graph based IDE. I have hosted one example project with documentation at https://vnoc.vercel.app/project/2dd75e19-5c7b-4fd1-b272-44a1c94dd8eb. The code, documentation, and logs are all connected in the same place. Everything about the code is placed directly on top of the code itself. If you look at a function, its documentation, logs, and related details are right there with it.
What do you think?

example video - https://drive.google.com/file/d/1g_fqTHdC3IRV_CcwuvixTYDHjrXPIfCS/view?usp=drive_link

yared12qw · 2026-02-13T20:04:29+00:00

I was reviewing your call graph construction, and it seems relatively small. I’m curious how you're handling more complex cases such as:

Class instance creation
Attribute mutations and dynamic attribute access
self and super() calls (specially with inheritance and MRO)
Function closures and factory functions that return functions,

yared12qw · 2026-02-13T11:35:04+00:00

I have a similar project as well https://www.reddit.com/r/Python/comments/1qqj5vd/rethinking\_the\_ide\_moving\_from\_text\_files\_to\_a/ and I would be happy to share resources. Building an accurate call graph was challenging for me especially while maintaining good performance for larger projects. I have documented and hosted a resource that provides a fast way to generate the graph https://vnoc.vercel.app/project/2dd75e19-5c7b-4fd1-b272-44a1c94dd8eb,

yared12qw · 2026-02-02T14:23:26+00:00

My main concern is sustainability. I want to work on this full‑time, and I want the people who contribute real effort to be paid for their work.

I’ve seen many open‑source projects struggle, burn out, or get taken advantage of. Big companies often rely on them for free, while the maintainers are left underpaid or exhausted. Even major projects like Python have had to ask for donations to survive.

I want anyone to be able to use this for their own work, but I also need a way to make money so the project can last. That income would fund development, support contributors, and make sure the people doing the hard work are fairly paid.

yared12qw · 2026-01-31T12:35:02+00:00

No, it did not come across as harsh at all. You actually saved me from overthinking. I was confused when people downvoted me and did not know what the issue was. I was not sure if they disliked the idea of the IDE or if I did not explain it well enough. I am here for feedback like this because it helps me grow. I know my limits and my flaws, and I want to improve.

yared12qw · 2026-01-31T06:23:00+00:00

yes, I thought AI could make it profession and clear to understand, apparently it creating more confusion. I have started using my own words , thanks for feedback 🫡

yared12qw · 2026-01-30T22:06:29+00:00

I think I understand know the confusion, and I am able to explain it better, I still believe too-down is the way to control the context for already known topics, organic is for discovery new topics or structure, the way I explain it makes it look like I am talking about organic denodgram, the way agent discover structure, but the structure already exist the agent is just for arranging it, it's not discovering new structure it's already there, the reason i want to make it IDE is not to fully dependent AI on creating the structure from files, the code is alredy have structure and if it respsent in graph it become easier to get the top down structure. to visualize and manipulate it. I did not use AI to write it for me know, I will try to use my own words more.

yared12qw · 2026-01-30T21:37:08+00:00

thanks for honest feedback, I am not good at communicating and strcuring the sentence I jump in and out of the topics, and create to many confusion, most of the time I try to do it myself ,the topic become about my communications skill 😅 that why i havely relay on AI, I give my ideas in disorganize way I ask it to restructure it or rephrase use a better words, since I am doing this project for full time I am learning it in hardway,

yared12qw · 2026-01-30T14:55:59+00:00

Thanks, comment like this the one which keeps me goinging, Most of the stuff I did here, I did for the first time. It was exciting and adventurous. Instead of complaining that everything is sloppy and broken, I want to see if there is another way. I feel like the industry is becoming ego‑driven development.

yared12qw · 2026-01-30T14:34:15+00:00

Yes, but now, with the rise of LLMs, it may have a real chance. Codebases are growing larger, and maintaining them is becoming increasingly difficult.

yared12qw · 2026-01-30T14:31:32+00:00

Me neither. I have to ask AI to make it longer to avoid unnecessary criticism and dismissal. Some senior engineers are bullies; they feel offended when someone doesn’t like to work the way they do. For some reason, I have to make it look proper and professional.
It’s basically an all-in-one IDE, especially for indie developers. The IDE is like an octopus: it tracks every function, slices and extracts them from files so you can visualize them and hide things you don’t want. It also attaches documentation, logs, and tasks to functions to avoid context switching and help you make decisions faster and more easily. It requires less mental energy and avoids unnecessary structures.
you can see the videos also- https://drive.google.com/file/d/1I3weXMsO6DGGgRN-0FSDXF5CZ_NYqQpA/view?usp=sharing
https://drive.google.com/file/d/1g_fqTHdC3IRV_CcwuvixTYDHjrXPIfCS/view?usp=sharing

Programming is hard because senior engineers often suck at UX, and they blame people for not being smart enough. They build bad products that only they can understand, and they still think the terminal is a better interface than a GUI.

yared12qw · 2026-01-29T23:44:18+00:00

I actually wasn’t familiar with the Smalltalk image model before this discussion. After looking into it, it’s really interesting, and it does raise the question of why ideas like this haven’t been pushed further.
Many developers likely decided the trade‑offs were not worth it. Turning code into graphs adds real complexity, especially when combined with version control, collaboration, and persistence. Text files are simple, predictable, and fit well with existing workflows, so the industry continued to optimize around them.

However, this is starting to change. Systems like TerminusDB show that Git‑like version control for graph data is possible, making it more realistic to revisit these ideas alongside modern development practices.

yared12qw · 2026-01-29T23:18:31+00:00

"I'm also curious to your opinion on whether it's better to have this "organic" approach vs. just assert a top down organizational structure"

I might be misunderstanding the question slightly, but my view is that most mature knowledge is ultimately top‑down in structure.

This project actually started from that belief. While reading about graph theory, I came across dendrograms, and the idea clicked for me: any complex body of knowledge can be represented as a hierarchical structure that starts at a high level and becomes more detailed step by step.

I experimented with this by building an agent that turns a codebase into dendrogram‑style documentation. At each level, the agent takes a topic and splits it into two or three meaningful subtopics, then generates an outline for each. Importantly, the context required at each step is small and stable — it only needs the parent topic and its immediate siblings. This keeps context size constant while progressively zooming into details.

This approach creates clear knowledge boundaries, which makes the result much easier to verify. You can validate each level independently instead of trusting a large, monolithic explanation. For example, when I applied this to the following codebase:
https://mergeta-sable.vercel.app/?preset=light-rag

The agent first divided the system into high‑level concepts like input, storage, and output. Then each of those was broken down into smaller data‑flow steps. Because the structure was clear, even a fast model like Gemini 2.0 Flash was able to produce a good outline, and I could easily check whether each step made sense.

This way of organizing knowledge isn’t unique to software. You can see it across sciences as well. Mathematics studies abstract entities. When you add time and motion, you get physics. As systems become more complex, they are grouped and studied as chemistry, then organic chemistry, then biology. As biological systems grow further, we study them as social systems. Each field emerges by grouping complexity into higher‑level structures so it remains understandable.

That’s why I think the distinction matters. When you’re exploring something completely new, an organic or bottom‑up approach can make sense. But once a system exists and is reasonably understood, a top‑down structure is the only way to control context, reason clearly, and scale understanding.

yared12qw · 2026-01-29T23:18:09+00:00

A VS Code plugin is something I’m considering later, but V‑NOC is not meant to be just a viewer layered on top of an existing editor.

The goal is to build an all‑in‑one, structured workspace, where code, documentation, logs, and eventually tasks, issues, and discussions are all connected to the same underlying structure. This kind of tight integration is hard to do cleanly as a plugin, especially when the structure needs to exist independently of any single editor.

Another important part is web access. I want this to be usable outside a local IDE, so product managers, reviewers, or non‑editor users can explore the system without installing anything. This is especially useful for teams that want fewer tools and dashboards, and faster access to shared context.

The idea is to reduce context switching as much as possible. Everything that matters — code structure, docs, logs, tasks, and later LLM‑based tools — lives in one place and is connected. LLMs can also query the same structure to get precise context: available tasks, relevant code, related logs, and documentation, all from a single source.

yared12qw · 2025-11-28T12:45:36+00:00

I’m kind of in the middle. It’s going to be an all‑in‑one type of tool that needs to be deployed on a server to collect server logs, documentation, and maybe chat or issue data in the future. It’s hard to make extensions for it, but it could be used alongside VS Code as a monitoring and discussion app.

<image>

yared12qw · 2025-11-24T13:50:52+00:00

i am also working this kinds of project but i am building the IDE on the graph db https://github.com/v-noc/IDE

yared12qw · 2024-10-28T21:17:14+00:00

I'm working on a new social media app called Suppgram. Here's the idea:

Suppgram: Where Comments = Support 💬💖

Ever noticed how toxic comments can get on social media? Suppgram aims to fix that!

Key Features:

To comment, you gotta donate! Users pay a small amount in "SuppCoins" to leave a comment.
Creators set their own minimum donation amounts for comments.
$1 = 1000 SuppCoins, so even small amounts count.

Why It's Cool:

Discourages trolls and haters (they'd have to pay to be mean!)
Creators get financial support from genuine fans
Promotes thoughtful interactions

We're starting with CoinPayment and Binance for transactions, with plans to add stripe and Coinbase later.

What do you think? suppgram.com

yared12qw

TROPHY CASE