Yared Ts

Love building things.
On a mission to Make Programing Great Again,

[Yared Ts @tsyared]

@omarvvvr

[Yared Ts @tsyared]

@hthieblot miniclip

[Yared Ts @tsyared]

@RaminNasibov Rise of Nations

[Yared Ts @tsyared]

I'm experimenting with an all-in-one graph-based IDE.https://t.co/YrOV24Ic5C

Code, documentation, learning, debugging, version control, semantic-aware diffs, and AI agents are all connected in the same graph.

The hypothesis is simple: as AI makes writing code easier, understanding systems becomes the real challenge.

Maybe the IDE should be organized around relationships and knowledge, not just files and folders.

[Yared Ts @tsyared]

@lucasmeijer Yeah. Sometimes it feels like software architecture is just a stack of hotfixes that became standards over time.

[Yared Ts @tsyared]

The future of programming isn’t smarter AI.
It’s better structure

[Yared Ts @tsyared]

I also hosted the Claude Code and LightRAG codebases with their documentation inside the IDE so people can explore how the system works in practice:

https://t.co/xzuRHLeFie

One thing I think is really powerful is that you can isolate and share a single function with its surrounding context and call tree, instead of sharing an entire repository or file. For example:

https://t.co/wobeUyCxbW

The idea is to make code more navigable and collaborative. Rather than scrolling through huge files, you can focus on one function, see how it connects to the rest of the system, attach docs/logs/discussions directly to it, and work in a scoped environment.

I think this becomes especially useful for AI-assisted development. Instead of feeding the model an entire repo, you can sandbox only the relevant part of the system with structured relationships and supporting context. The AI can then debug, review, explain, or teach directly on the canvas alongside the developer.

I’m basically trying to move away from the “infinite file + chat thread” workflow into something more visual, structured, and easier to reason about for both humans and AI.

[Yared Ts @tsyared]

Hey, what do you think about this project I’ve been building: https://t.co/YrOV24HEg4

It’s a graph-based IDE that tries to rethink how we interact with large codebases. Instead of treating code as just files and folders, it uses both static and dynamic analysis to transform the codebase into connected blocks of functions, classes, and systems linked through a call graph.

The main idea is reducing cognitive overload. You can isolate a single function or feature, see only the relevant call tree around it, attach related docs/logs/tests/discussions directly to the node, and work in a focused sandbox instead of constantly jumping between files and tabs.

It also includes semantic-aware diffs and navigation, so changes are understood at the function/class level instead of only raw text diffs. The goal is to make code easier to understand, navigate, and reason about — especially in large or legacy systems.

For AI, I think this structure is even more useful. Instead of throwing an entire repository into context, the AI can work inside a scoped canvas around a specific function or subsystem with its related dependencies and documentation. The AI interface itself is canvas-based too, so it can visually teach, debug, review code, explain relationships, or walk through execution flows collaboratively instead of only chatting in a long text thread.

I basically believe the biggest problem in software complexity is structure and navigation, not writing syntax. So this project is an attempt to make code more visual, connected, and understandable for both humans and AI.

[Yared Ts @tsyared]

I’m almost a year in, still struggling, still confusing people, and still trying to figure out how to build the simplest and most flexible all-in-one graph IDE — because I believe structure is the answer, not being “smart.” Code should be easy to learn, to navigate,manage, and fully connected, where docs, tasks, and knowledge all live together instead of being scattered across files and tools. https://t.co/jXjcXU6Wkp

[Yared Ts @tsyared]

@thesayannayak English

[Yared Ts @tsyared]

@ThePrimeagen

[Yared Ts @tsyared]

@Layton_Gott Coding was never the skill required, no one code a code that not know by other coders, it's was just about business logic and resource management

[Yared Ts @tsyared]

@beffjezos B2c , consumer are host and won't settle for okay or safe

[Yared Ts @tsyared]

@DanielSmidstrup struggle first then look for solution

[Yared Ts @tsyared]

@andrewchen How would he know what to build if he doesn’t know what’s possible to build? Not everything is buildable.

[Yared Ts @tsyared]

@original_ngv coming soon, semtic aware version control, insted if showing thus whole file is changed it tracke function leve diff, with documention https://t.co/R8QTrnYlMe

[Yared Ts @tsyared]

I back myself. I believe the structure of knowledge is the key to intelligence, and anyone can understand any system easily with the right tools and a clear structure. Complexity is a sign of a bad system, not intelligence. And the path of LLMs should be easily understandable and verifiable by anyone, not based on blind trust.
https://t.co/xzuRHLeFie

[Yared Ts @tsyared]

Graph-based IDEs can help solve this. I’ve hosted Claude Code as an example here: https://t.co/xzuRHLeFie

It turns a codebase from files/text into nodes and edges each function and class becomes a trackable unit. Docs, logs, and tasks are attached directly to those nodes and move with them as the code evolves.

Instead of re-explaining things or relying on RAG to guess, both humans and LLMs can traverse the call graph and get the exact context in place function-level docs, relationships, and usage without searching.

This reduces cognitive load for humans and gives LLMs structured, scoped context by default. just query the graph and get the full picture. You can also sandbox functions to explore or test them in isolation. https://t.co/wobeUyCxbW

[Yared Ts @tsyared]

What do you think about a graph-based IDE?https://t.co/xzuRHLeFie. Instead of digging through folders, it maps your code as a graph—making it easier to learn, navigate, and understand large codebases by showing relationships, not just files. It reduces cognitive load for humans, gives LLMs richer context, and brings docs, logs, and tasks into one connected place. You can also sandbox individual functions to explore and test without affecting the rest of the system. https://t.co/wobeUyCxbW

[Yared Ts @tsyared]

@skeptrune i have a product https://t.co/R8QTrnYlMe