jonator

Yep, but the code is still reviewed/tested/validated before merging (so -vibe)

Assume reusable spaceflight eventually brings launch cost close to the cost of fuel. This is close to happening.

The overhead of building out grid and power infrastructure on land would then exceed the installation speed and cost relative to space based deployments.

Also assume the compute that does make it to space has a short shelf life anyways so lack of ability to repair is a non issue. As we scale manufacturing on land this will increasingly be the case.

China has already run experiments and served models from space, so we know the heat dissipation equation is solvable.

Finally you’d arrive at a similar model that’s already proven successful with Starlink but applied to serving inference.

The key question is speed to scale new deployments to meet demand. If the markets demand is near infinite, they will choose to fund space based deployments over slower land deployments.

Energy will be the biggest bottleneck to data centers on land. Is not an issue in space. Space is the perfect env for running compute.

90% of my dev workflows have moved to Devin cloud agents.

I don’t miss the days of fumbling around with my local repos across my multiple agent work trees or clones.

I just throw a task at Devin and I get a PR a few moments later.

Then it monitors the PR for any failing CI or review comments without me in the loop.

Now I can have 10+ Devin’s running at any given moment as I walk home from the coffee shop.

It seems like now’s the time to rethink how we do education.

In my personal post academic life, I’ve found LLMs to be an incredible teacher. Almost like the best professor in the world at my fingertips. I use it to generate quizzes on demand to test for my own knowledge gaps.

However, if I use it to speedrun over concepts I should be learning, I may achieve my end goal but I wouldn’t actually learn many of the details.

I think it requires an approach where you have to continuously audit your own understanding as you work with the concepts. You must slow down until you’ve confirmed this. Only once you know the concepts deeply and have retained them in your own memory can you then go all in with the LLM.

Fully agree. Perhaps I should have clarified that it’s primarily for agents now, not just engineers.

I’ve found a good counter to this is having agents visualize and explain the architecture of the system. Then I gain just enough context to figure out what I’m trying to accomplish.

Also, as always, a highly modular codebase is very important. If I only have to reason about a single module then I don’t have to have full context on system.

It seems we’re now in a world where engineers are responsible for creating a good environment where an agent is able to gain context on the architecture and validate its work via tests (e2e, unit, smoke, etc). Then it can get into its own feedback loop and find the correct solution on its own much faster.

I've been using Opus 4.5 via Claude Code

I can attest to everything. Using Tidewave MCP to give your agent access to the runtime via REPL is a superpower, especially with Elixir being functional. It's able to proactively debug and get runtime feedback on your modular code as it's being written. It can also access the DB via your ORM Ecto modules. It's a perfect fit and incredibly productive workflow.

https://jonator.dev

I think frontier models are getting to the point where we can start to reach higher trust agentic workflows.

As a hardcore AI chat user, I'm often frustrated with the single-agent workflow, where a single context window is used for even very long conversations. If I want to change the topic, open a thread, or go on a tangent, I often end up compromising the main thread and I'm forced to copy context over if I want to dive into something.

To solve this, I'm working on a collaborative AI agent orchestrator that models the solution as a group chat with humans and AI agents, including an agent orchestrator.

You can spawn participating agents with the orchestrator who will decisively route messages to the existing agents, or spawn new agents if needed. Also, you can open agent details and send messages directly to existing agents, similar to threads in slack.

So far, I have MCP integrations working with Linear and GitHub, but plan to add many more.

I've been working on this just over 2 weeks, making heavy use of 4+ concurrent Claude Code agents. This would have been impossible otherwise.

If you're interested, feel free to DM on X.

https://x.com/jon_ator/status/2010370649147998459?s=20

  Location: NYC
  Remote: Yes
  Willing to relocate: No
  Technologies: React/Next.js, TypeScript, Swift, Golang, Elixir
  Résumé/CV: https://www.linkedin.com/in/jon-ator/
  Email: jon (at) ator (dot) us

The issue you described is an issue with AI?

If you're reading this there's a great opportunity to pull a Linear move and disrupt the entrenched players with a 10x better UX. Although the hardest nut to crack here are the network effects.

I'd argue the opposite of ass kissing and yes-men behavior is what is actually seductive.

I agree. My take is, with tech and the social realm, it tends to provide watered down alternatives that distills the social fabric into a more sparsely connected graph. It's not absolutely bad as there can be good that comes about it, but in general it re-engineers the incentives to connect.

Meetup.com (Luma, etc): replaces the need for existing heavily maintained communities of friends and family in your location with siloed random encounters. However, it shortens the path to meeting people that share niche interests.

Dating apps: replaces the need for men to spontaneously approach women they meet in their daily life or in social/family circles (even bars) with a heavily idealized profile centered around physical and emotional attractiveness. They are not only dominated by men, but they typically only disproportionally benefit a small % of those men.

Facebook: you can keep in touch with the lives of more people at scale, but it reduces the incentive to catch up in person with the people you actually care about. This can lead to genuine in person connections being replaced with a feed of people you really don't know.

Take it with a grain of salt.

Even if you're working on a large complex system like that, I believe coding agents are still useful at at least taking highly specific prompts/instructions you write and doing the writing for you. Then doing other tedious tangential work like generating unit tests over a pure function, adding comments, generating documentation, etc that all increase the quality of the codebase without requiring toil on your part.

With especially novel or complex projects, you'd probably not expect to use the agent to do much of the scaffolding or architecting, and more of the tedium.

I agree and do experience that. Perhaps to clarify, I mean that it (unlike humans), is always down to code alongside you. It will never complain, get sick, have a life event. etc.

For me the fun part of coding is having visions of products or systems I'd like to exist, and writing code only as a means to an end.

Claude Code (AI coding agents/assistants) are perhaps the best thing to happen to my programming career. Up until this point, the constraint going from vision to reality has always been the tedious process of typing out code and unit tests or spending time tweaking the structure/algorithm of some unimportant subset of the system. At a high level, it's the mental labor of making thousands of small (but necessary) decisions.

Now, I work alongside Claude to fast track the manifestation of my vision. It completely automates away the small exhaustive decision making (what should I name this variable, where should I put this function, I can refactor this function in a better way, etc). Further, sometimes it comes up with ideas that are even better than what I had in my head initially, resulting in a higher quality output than I could have achieved on my own. It has an amazing breadth of knowledge about programming, it is always available, and it never gives up.

With AI in general, I have questions around the social implications of such a system. But, without a doubt, it's delivering extreme value to the world of software, and will only continue the acceleration of demand for new software.

The cost of software will also go down, even though net more opportunities will be uncovered. I'm excited to see software revolutionize the under represented fields, such as schools, trades, government, finance, etc. We don't need another delivery app, despite how lucrative they can be.

There's a lot of economic explanations that seem perfectly legitimate.

I'm wondering if a simple contributor is the fact that many people are moving away from their immediate family. Then you feel more on your own when considering having child, which is significantly more daunting. I think a network of friends helps, but is simply not the same as parents/siblings/cousins sharing the load and advice. Let alone the experiences.

Also, it seems there's a negative feedback loop, where each person that chooses to postpone or not have kids influences their network to do the same.

Capitalism does facilitate monopolies or industries with razor thin margins like airlines. However, the space of competition is a revolving door with constant opportunity to create something better (that people want) than the established players or to enter a new arena entirely. Ultimately, since consumers are the choosers, it works in their favor. It was the consumers that wanted these companies to exist, and the profits are a proof of that.

However, sometimes there are unpriced externalities like the competitive advantage of removing your own manufacturing waste by dumping it into a stream. That is where governance (whether self or the state) comes in.

Reminds me of the Linear story. You can disrupt a set of established players by focusing on simplicity, opinionated design, and maximum performance via hardcore engineering.

I've done the same, but with AI generating a lot of the boilerplate, and helping generate automated tests, has accelerated this process considerably.

Like for a dev server? Are you using a file watcher? I also find a test watcher helpful to increase confidence in the agents changes.

Recently, the cursor agent panel supports multiple tabs and sometimes I use that to kick off multiple non conflicting agents. You may prefer a separate window. Further, to avoid file conflicts completely, you could use a git work tree.

And you don't think capitalism is the reason we have these computer jobs to automate away in the first place?

Oh interesting. So how do messages come from the container? Is there a host elixir app that is running the agent env? How does that work?

I'm assuming you're using FLAME?

How do you protect the host Elixir app from the agent shell, runtime, etc

Exactly. And as more software is written, the demand and possible set of softwares increase.

It's really a matter of positive sum/growth mindset vs scarcity/status quo mindset.

You can think of it as just automating the boring tedious stuff so us humans can focus on the harder problems like strategy, direction, design, GTM, etc.

The days are numbered where humans are sitting typing out code themselves.

It's akin to the numbered days of type writer secretaries of the 20th century.

I believe it will raise the standard of what is valuable. Now that LLMs can now handle what we consider "mundane" parts of building a project (boilerplate), humans can dedicate focused efforts to the higher impact areas of innovation and problem solving. As LLMs get better, this bar simply continues to rise.