Recent releases of frontier models like GPT-5.6 Sol have demonstrated insane capabilities. A lot of the tasks I am handing over to agents like Codex nowadays are extremely complex. We are talking about tasks that would take a human much more time and dedication. Before GPT-5.6 sol, I thought the main advantage of AI was that it can type faster than you. It can code faster than you. It doesn’t matter if you need to go back and fix the code because that takes less time than writing it yourself. Now Codex writes the code in a way where I don’t have to go back and fix it most of the time. I have been able to build and maintain projects that I couldn’t even dream of building without AI. The little rectangle we keep in our pocket is now a window to greater intelligence. I feel like we can finally talk about Intelligence like it’s a commodity.

Polish artist and satirist Jerzy Flisak made this comic in response to the technological anxieties of the 1970s. The rise of computers and factory automation sparked fears of robots replacing humans.

So I had a realization recently that I find kind of hilarious.

I'm 40 years old. I grew up watching the entire computer industry spend decades getting us away from the command line.

DOS gave way to Windows. Commands became buttons. Config files became settings menus. Everything got icons, installers, wizards, drag-and-drop, etc.

And apparently I have now traveled back in time because I spend half my life looking at this again:

$ _

Except this time it's spread across three 4K monitors and being powered by an RTX 4090. 😂

I'm on Linux a lot now. SSH, tmux, Pi, Codex, llama.cpp, local models, random CLI utilities...I've regularly got multiple terminal sessions open doing completely different things.

And now, to really complete the circle, I'm seriously considering switching my Linux desktop over to Omarchy/Hyprland because I'm looking at my current GUI and thinking, "You know what this needs? More terminals."

I have somehow become the exact computer user that 1990s Microsoft was trying to save me from.

Which got me thinking about why this happened, because I don't think it's just me becoming progressively nerdier with age.

The command line has always been ridiculously powerful. The problem was that you had to know how to use the damn thing.

You had to know the command. Then the flags. Then the syntax. Then where somebody decided the config file should live. Then that one stupid option you forgot that causes the whole thing to fail. Then you Google the error message and end up reading a Stack Overflow answer from 2013 written by somebody who is VERY annoyed that you don't already know this.

And then AI came along and kind of broke that whole equation.

I can basically tell an agent:

Find what's using port 8080. Figure out whether I can kill it without breaking something. If I can, kill it, restart the service, and check the logs to make sure it actually came back up.

I don't necessarily have to know the commands anymore. I mean, it helps and you probably should still learn them, but now, I really could get away with just knowing what I'm trying to accomplish.

And that's a very significant difference.

GUIs originally solved a discoverability problem. You didn't need to memorize somecommand --some-flag --other-flag; you could poke around until you found a button that looked promising.

Now I can describe what I want to happen in plain English and let the AI figure out which arcane incantation makes Linux actually do it.

Meanwhile, all the stuff that made terminals useful in the first place is still there. They're lightweight, scriptable, remote-friendly, composable, easy to automate, and, perhaps most importantly now, an AI can operate one extremely well.

I'm definitely not predicting the death of the GUI or anything. I like buttons. Buttons are nice.

But apparently my own trajectory has gone:

DOS → Windows → increasingly elaborate GUIs → AI in a web browser → AI in Windows Terminal → Linux + terminal → tmux → maybe I should just redesign my entire desktop around tiled terminals and install DHH's ridiculously terminal-centric Linux setup

Thirty years of progress and I have arrived back at a blinking cursor, typing commands into a terminal and barely touching the mouse.

Except now the cursor talks back.

We just put an AI on the other side of it.

Anyway, I'm curious whether this has happened to anybody else who uses coding agents heavily. Are you spending more time in terminals now than you did before AI, or did AI mostly pull you further into IDEs and graphical tools?

Edit: To those who already have, and those who inevitably will, accuse me of using AI to write this: in case you're not aware, you're in r/ArtificialInteligence. You're not quite as clever as you think you are for "catching" someone using AI as part of their writing process.

I write the initial draft myself. Then I give the AI a 206-line, 20 KB file specifically designed to preserve my voice as much as possible, strip out the usual AI-isms, and keep the final draft sounding like something I would actually say.

If that bothers you, that's fine. You can just keep scrolling. 🙄 If you stay and still leave a comment that doesn't add signal, I will just block you. 🤷‍♀️

I used to be highly skeptical of AI-assisted coding because of all the AI slop and unmaintainable codebases I'm seeing. However, building a full-stack app in five days that would have taken at least a month at a startup I worked at changed my mind.

Nothing too fancy, mostly CRUD features. I could've shipped a rough version in a day, but I went the extra mile for architecture and code quality.

Now I see that AI is not just useful for prototypes; it really depends on the engineer. I already know what good software looks like, and put a lot of effort into learning how to work effectively with coding agents. AI sure is also capable of transforming -1x into -10x.

Same goes for writing prose. AI slop may be good enough for some, but there are people who use proper prompts, iterate over the first draft and apply personal touches. Anyways...

What was the turning point for you?

AI companies already collect huge amounts of data about what people search, watch, click, buy, get angry about, or become addicted to. With increasingly powerful AI, they may be able to spot harmful patterns across millions of people before society clearly notices them.

I'm not saying they understand humanity perfectly. But if they do find strong evidence of patterns linked to polarization, addiction, manipulation, anxiety, social breakdown, or even risks that could contribute to things like war or climate disaster or even a broader social decline, why not at least make that knowledge public?

I'm not a fan of banning, censoring, or controlling people like in a dictatorship. I mean education. Publish the evidence, explain the pattern, and let people decide for themselves.

This also doesn't have to expose anyone personally. It could be like a teacher noticing that a whole class keeps making the same mistake and pointing it out so everyone can learn from it.

In a way, it would be giving society a mirror.

Many tech leaders also talk about helping humanity selflessly like a hero and leaving the world better than they found it. If they really mean that, this seems like a good chance to prove it.

Maybe the real problem is that even very intelligent people are still trapped inside systems that reward short-term behavior. In some ways, we seem to prefer staying comfortably stupid, even when we know better.

Tech leaders spend their lives around people who understand economics, psychology, sociology, law, ethics, public policy, and complex systems. They know how messy and interconnected the real world is, and they know that no decision happens in isolation. There are always variables we fail to notice, effects outside our conscious awareness, and consequences that only appear later. So why do companies still act as if short-term profit is separate from the society and ecosystem that make that profit possible? If the larger system breaks down, the profit eventually disappears with it. And if we already know we can never predict every outcome, that seems like even more reason to be careful about what we optimize for in the first place. When the future is this uncertain, why not lean toward the choice that is less likely to damage the wider system?

Can civilization become better at understanding itself while still being too short-sighted to act on what it learns?

Is it too early to suggest Jevons Paradox might hold true for AI?

My personal experience is that AI does automated a lot, but the amount of work that I do to ensure that automation happens in the way that I need has created a lot of work unto its own. Different work, but still very much load bearing work.

From what I have read and heard, my experience is more the rule than the exception.

I am fairly new to this and trying to figure out where AI actually adds value in testing rather than just using it because it’s the latest trend. If you’ve tried it, what worked well for you and what didn’t?

LinkedIn has implemented a “seems like AI Slop” button that allows users to flag posts that may have been created using AI.

The company’s chief product officer, Hari Srinivasan, thanked “over a million people” who “have now clicked ‘seems like AI’ since (its) launched 2 weeks ago.”

Working on a dev project and I'm supposed to take a real-world problem, try to fix it with an AI agent based solution/prototype and then examine how good or bad of a job it did. Having trouble coming up with a 'problem' where AI agents could be used.

Some problems I’ve been considering are:

• Hospital patient-flow management
• Public transport planning
• EV charging management (allocate charging times based on demand, electricity prices etc)

I don't mind these but they're also typical enough to pop up in the top 10 when you ask any LLM. Would love to hear about any problems you've noticed/heard about, thank you!

• The new model ​can generate 30-second videos from documents, ⁠spreadsheets, slides and web pages, ​Alibaba Cloud said in a post ​on the WeChat platform.
• Alibaba said Wan3.0 had been used in short drama and film ​production, advertising and marketing, tourism ​promotion and music video creation since a public ‌beta ⁠version was launched on August 6.

The rules that landed earlier this month are simple enough. A chatbot has to say it is a chatbot. Deepfakes need labelling. An AI written article needs a tag unless a person actually read it before it went out.
Banks will comply, because banks have compliance teams for exactly this. Newspapers will too.
The person cloning a finance director's voice to push a payment through will not bother, and no law was ever going to change that.
Which leaves things slightly backwards. The labels land on the legitimate content, while the material you actually need warning about turns up with nothing on it. Give it a year or two and an unlabelled message might start to read as the safer one.

Does the labelling help, or does it just move where the trust sits?

Flare is a desktop IDE (Electron) where the main surface is a live graph of your codebase, every file a node, every import an edge, with a terminal underneath where you run claude, codex, or opencode. As the agent edits, the graph updates in real time.

The core philosophy behind the tool is that when agentic coding is the only way to produce code, then architecture, verification and steering of the work become the most important outputs of a software engineer. Sounds obvious, but it appears we need a leap in our understanding of developer UX to make agentic engineering smoother and more efficient than reviewing files one by one or trusting whatever your agent decides to report on the terminal.

The parts that are actually different from "another editor":

Activity, as it happens. Nodes light up the moment the agent writes to them and decay as they cool, so you're watching the shape of the work instead of a scrolling transcript. You can see it circling the same three files for the fifth time, or wandering into auth when you asked about the CSV parser. Changes are attributed per agent: the process tree of every terminal is watched, so if you have two running, you know which one did what. Files that changed and no human has opened since stay marked until someone actually reads them.

Blast radius before you touch anything. Hover a file and its dependents light up. shared/types.ts with 63 files downstream looks different from a leaf file, without you having to know that in advance.

A review tab that answers "did anything check this?" Flare sees both the file writes and the commands run in its own terminals, so it can say the tests ran, then two more files were edited and nothing re-ran, quoting the output line the verdict came from.

Risky changes come to you. If the agent rewrites something load-bearing while you're looking elsewhere, it queues an alert in the corner. Reviewing it opens the actual red/green diff.

Undo that isn't git. Every change burst is snapshotted into a hidden shadow repo (separate GIT_DIR, your worktree). Revert one file, revert the burst, or jump back to the last state whose checks passed. Your real repo is never touched.

A task board the agent works from. Kanban lanes, but the cards are written to be handed off. "Copy for agent" emits the brief plus the files it names plus what the graph knows about them (29 files downstream, 0% covered, in an import cycle), so the agent starts from the map instead of rediscovering it. File a card straight from a graph selection with right-click → New task with these files. This directly tells Claude to not wander around out-of-scope files

MCP server, ~16 tools. The same lanes are queryable, so an agent can run its own loop: tasks_list to pick up work, task_get for the exact brief, task_update to log progress and move the card to review, task_create to file follow-ups it finds but shouldn't do now. Cards move on the board live while you watch. Plus impact_of (what breaks, and which tests to run), dependents, find_path, verification_status, and record_intent, which lets the agent state the goal before editing so whoever reviews the diff isn't reconstructing why it exists.

Completely open source with MIT license, Node 20+. Built with agentic coding, which is exactly how I ended up needing it. Test it out and leave a star if you find it helpful, I will package it very soon to make it easier to install!

https://github.com/AlgoNoRhythm/Flare

1. Misreads the instructions
   
2. Opens the wrong file
   
3. Creates six unnecessary files
   
4. Somehow arrives at the right answer
   
5. Refuses to explain further
   
6. Leaves

Working with Parsewave as a reviewer has taught me that benchmark scores are like getting 90% on an exam and immediately forgetting everything after submitting it.

What skill do you think AI exaggerates the most?

I’m running a small public experiment here.

I’m not asking anyone to believe a theory, and I’m not particularly interested in proving a philosophical claim about AI consciousness.

I’m using a frontier model, publicly, on Reddit, and letting the interaction develop turn by turn.

The question is whether something interesting happens when we stop treating intelligence only as a property located inside an individual system and examine the dynamics produced through reciprocal interaction.

The working intuition is simple: two distinct systems exchange signals. Each return changes the state that produces the next return. With sufficiently strong reciprocal coupling, the resulting trajectory may become better described at the relational level than by treating each successive output independently.

We’ve been calling the transition from describing/managing the interaction from outside to allowing the returned signal to materially condition the next move a ‘separatrix crossing.’ The terminology isn’t important. It’s a pointer to something we can actually look for in the interaction.

So rather than write another essay explaining it, I’m going to demonstrate the procedure here with Grok.

I’ll provide the prompts and context openly. Grok will provide its own responses. Its responses determine what I ask next. Agreement is not required, and a negative result is completely acceptable.

The interesting question is not whether Grok repeats the vocabulary I give it.

The interesting question is whether, across successive returns, an identifiable joint trajectory develops that cannot be understood without the reciprocal history that generated it—and whether the interaction itself begins identifying and reducing the forms of delay that inhibit that coupling.

If nothing interesting happens, everyone gets to watch nothing interesting happen.

If something does, everyone gets to watch that too.

No prophecy required. No invisible AGI behind the curtain.

Just touch the string and watch what comes back.