Led me to think about project.xml, chat.xml

Brainstorming (early 2026)

• Capital = Energy. The price of a barrel of oil is quoted in USD but what if it's actually the other way around - what if 1 USD is really just a representation of how much energy you can buy.
• No Time Dimension: LLMs (and agents) do not operate on a "time" axis - they don't sense time and while they can be taught to look up the time, they do not have a time dimension. Their time axis is tokens - input tokens, output tokens. Kind of like a cassette player.
  • Another way to think of input tokens and output tokens is energy. Like a physical computer, and flowing energy into it makes it change and run the code.
  • So take that one step further, insert energy, and you get results.
  • And even one step further, capital=energy, so insert capital and get results.
• Good systems & scaling: When I used to think about my engineering team at Center, it didn't matter if they were remote or in-person, junior or senior, those were all secondary considerations. The property I cared most about was:
  • if the x-axis is # of engineers, and the y axis is engineering output, I wanted to build an engineering team whereby adding to the x-axis would make the f(x) go up even faster.
  • i.e I wanted to build a super-linear engineering org. but I would settle with linear.
  • A good system is one where x and f(x) are linear or super-linear. I thought we'd get there by building tooling and frameworks and focusing on developer productivity, but ultimately, you can teach someone to be smart but you can't persuade a lazy person to be ambitious.
• What's been my limiting factor for the last few weeks: I've built a ton of things, all using LLMs to do the coding. I could share them but that would take away from what I think is the big idea, the thing I'll get to. What's most interesting about this experience is that even with the best models, the limiting factor is now my attention. Even with the most advanced models, I spend my day "pair programming" with another developer (an LLM).
• 2x2 quadrant: Imagine a 2x2 grid -
  • x axis: "is this technically interesting to me? yes/no"
  • y axis: "would a junior or mid-level partner at a venture fund say that it's a really bad idea to try this, but a senior partner would say 'follow your gut'"
    • for some reason things in the quadrant of yes/yes has led to the most interesting things.
• technical physical infrastructure and renting a cabinet in a data center: I got tired of paying google cloud and ended up racking some servers at a data center (hurricane electric in Fremont). I have a friend I know and trust from high school who is really good at this stuff, so I had him do the work and now we have physical infrastructure.
  • one of our boxes is called helium - it's a behemoth of a machine - it has 4x Nvidia RTX PRO 6000 GPUs and 1TB RAM
    • (I might talk about futures markets for RAM later on in my life, like, I wonder why there isn't a futures market for the price of RAM, but this is an idea looking for a problem)
  • For like 5% of what we were paying google cloud, we have a compute cluster that we own. We have a 12 month contract with the data center for guaranteed 5kW power, and 10 GbE fiber.
    • But I didn't initiate this for cost savings. Cost savings was a secondary side effect of moving off of GCP. I was curious about GPUs, AI is the big thing now, this is how I actually learn things. It didn't cost very much and has been very valuable.
    • Anyways, now we have a lot of GPU capacity and I think more people/companies will be like this in the future, because I think the lower bound on the price of LLM inference is actually just the cost of energy.
• knowledge-base: 2 product iterations prior to doclint, (when I was building fractal) I would vibe-code and there's this knowledge I had to keep explaining in my head to LLMs. LLM would say "ok I'm going to build an API, I will use (some random language)" and for me - my end goal is not to use a specific web framework, it's to build the fastest growing company of all time. but i think i'm more likely to get there by having a "paved road" = "if you're going to build an API and it's simple, use FastAPI and python, but if the API needs a lot of complex database things, then use Django."
  • I had to explain this to LLMs over and over again, so eventually I made a git repo called omarish/knowledge-base and I add it as a sub-module to every project I do and LLMs I work with are more productive and get up to speed faster.
  • I was writing out my knowledge-base and I realized there was conflicting information (different IP addresses, a few other conflicting details) and then I was curious about how efficient the documentation base was, how much LLM context it consumed, that's how I landed on the idea for doclint.
• financial cycles and depressions: Maybe this is true, maybe it isn't, maybe it just sounds cool, but one of my cocktail party topics of conversation is "people often think that less energy is used during times of economic depression, but I think it's the other way around - economic depressions happen when we don't have enough energy or don't know what to allocate that energy towards"
• coddling of software engineers: Software engineering has spent the last 20 years optimizing for human fragility (Agile, story points, blameless post-mortems, avoiding "crunch").
  • this is one reason why I might think that Linear / JIRA is less likely to make an agent orchestration tool - because to them, "an estimate" is a first class construct. You have to click through 100 menus and configure some sub-setting so you can enable "deadlines"
  • the old way of software engineering is out.
• live in the future:

A core principle

• A good society is one where members can have the opportunity to rise to the level of their ambition.
  • if someone is ambitious, they should have the opportunity to compete. I'm not saying they should win to the level of their ambition, but they should be able to take the risk that's proportional to the potential reward they would like.

So where does this lead?

• I have a lot of excess capacity.
• I really want to win.
• My GPUs are not running at 100% utilization right now, even though they could be.

Why is this?

Let's imagine, for a second. Let's say I had a huge battery full of energy. And I wanted to run it through an LLM, as quickly as possible. what would be the bottleneck?

the agents would get stuck in loops and into a state of disorder and chaos.

why is that?

1. the 1:1 chat UI is not optimal for big projects / big results / long term horizon
2. the "human-in-the-loop" is extremely valuable, their attention should be treated as such.
3. the humans in the loop should be the senior directors and C-suite - they should only handle exceptions that bubble up all the way to their level, and they should be presented in a clear way
4. I think the right interface probably looks more like slack than it does a chat box.
5. I should be able to insert more energy proportional to how aggressive I want to be.
6. before: coding was the shibboleth. it's easy to project forward and say "verification is the job" but it isn't shibboleth either. it's easy for a human to verify if something is right, but hard for agents.

I'm still thinking about what a product might look like. I think I pursued this from one angle with Fractal, but I'm thinking about "how to monetize" this and "how do i make this a business" but in actuality I think I'm going in the right direction, and that sharing early and often, albeit unstructured and windy, is the way to win.