Competition is essentially dead for that segment given there is always outward growth.

With that being said, AI enables smaller players to implement their visions with enough completeness to be viable. And with a hands off approach to code, the underlying technology mindshare does not matter as much.

My raw thought: I wonder how many people are really objecting to the loss of exclusivity of their status derived from their relative eloquence in internet forums. When everyone can effectively communicate their ideas, those who had the exclusive skill lose their advantage. Now their core ideas have to improve.

Same idea, LLM-assisted: I wonder how many objections to LLM-assisted writing really stem from protecting the status that comes with relative eloquence. When everyone can express their ideas clearly, those who relied on polished prose as a differentiator lose that edge. The conversation shifts to the quality of the underlying ideas — and not everyone wants that scrutiny.

Same ideas. Same person. One reads better. Which version do you actually object to?

LLMs help to express what many people dont have the energy or ability to express. It also has a broader scoped view of protocol...It does not have emotions, which often leads to less than optimal discourse.

In many ways, it help those who are challenged in discourse to better express themselves...rather than keeping silent or being misunderstood.

On the "event → agent" gap: we've been thinking about this as a layered problem.

The bridge is a file write. agent-doc is user-initiated (edit a doc, hit submit), but the diff pipeline doesn't care who writes the file. A watcher process — or any external system — can write to the file system, and the agent sees the change on next poll.

We already do this in a different layer: corky (https://github.com/btakita/corky), our email tool, runs a watch daemon that polls IMAP for new messages and syncs them to markdown files on disk. External event (email arrives) gets translated into a file-system change, which is the agent's native input format. Same pattern would work for session recovery: monitoring process detects flagged session → writes to a task file → agent picks it up.

Dashboard-as-document is something we're actively planning. The idea: a markdown template where a watcher fills in operational fields — session status, health checks, proxy assignments. When the watcher updates "active" → "flagged", the diff pipeline sees exactly what changed. The template gives structure; the diff gives the trigger.

The snapshot diff already works for this — partial support exists today via agent-doc's routing layer (external scripts can trigger submission when a file changes). What we're building next is auto-submit on file change and sectional write-back so the agent can update specific dashboard fields rather than only appending.

For sub-second latency, a lightweight daemon that receives webhooks and writes to the notification file or directly triggers an agent submit. But for most operational tasks, a polling interval (ours runs every 30 seconds) closes the gap well enough.

The gap you're describing — "thing happened" to "agent knows about it" — is really about who writes the event into the file system. Once it's a file change, the diff pipeline handles the rest.

On concurrent editing — it's handled at two levels:

*Ownership:* Each document is claimed by one tmux pane (one agent session). The routing layer prevents two agents from working the same doc simultaneously.

*3-way merge:* If I edit the document while the agent is mid-response, agent-doc detects the change on write-back and runs `git merge-file --diff3` — baseline (pre-commit), agent response, and my concurrent edits all merge. Non-overlapping changes merge cleanly; overlapping changes get conflict markers. Nothing is silently dropped.

The pre-submit git commit is the key — it creates an immutable baseline before the agent touches anything, so there's always a clean reference point for the merge.

The routing layer uses tmux: `agent-doc claim`, `route`, `focus`, `layout` commands manage which pane owns which document, scoped to tmux windows. A JetBrains plugin lets you submit from the IDE with a hotkey — it finds the right pane and sends the skill command.

For context sync across agents, the key insight was: don't sync. Each agent owns one document with its own conversation history. The orchestration doc (plan.md) references feature docs but doesn't duplicate their content. When an agent finishes a feature, its key decisions get extracted into SPEC.md. The documents ARE the shared context — any agent can read any document.

It's been working well for running 4-6 parallel sessions across corky (email client), agent-doc itself, and a JetBrains plugin — all from one tmux window with window-scoped routing.

[1] https://github.com/btakita/agent-doc

https://claude.ai/share/cc12416b-723a-45af-ba13-4f342b005dd3

Well, the last couple sentences is me paraphrasing. But one thing that many in the West boast about is the ability to criticize the systems to improve said systems. Let's see if actions match the rhetoric.

I agree that people should be treated with dignity...but groupthink & herd mentality often strips people of their humanity.

So the criticism is really about culture & abstract attractors...not the individual people who often act rationally within the context of the system.

It seems the EPA cares more about enforcing CO2 production & making sure a homesteaders doesn't build a pond...than it does about extremely harmful & destructive chemicals dispersed across the planet by industrial & military waste.

So I suppose the research is good but the emphasis & enforcement is what really matters. And while there have been historical wins, the agency seems increasingly like a political revolving door to entrench industrial incumbants.

So we renamed our git branches from master to main...because of colonialism.

So what's the correct non-colonial word? ask, request, plea?

Some people here seem to like the word "summon". tsk, tsk, tsk

What if "doomerism" is a key component to demoralize people to accept "decisive and ambitious action"?

Note that most of the environmental policy talk is on a global level...blaming living people who aren't wealthy enough to benefit from financial capital. Making everyone who doesn't make their living off of financial assets have a worse quality of life...while those who benefit from financial assets even more wealthy.

Environmental policy talk is not on a local level. Never mind the water usage of the AI centers & how it affects communities. The farmers will have to sell their land so big capital to buy it on the cheap. The money pump always leads to accumulation of Capital.

It sure seems like the rhetoric goes one way. Making the rich richer...so they have all the carbon credits to do whatever they want...transcending the "tyranny of morality" while they fly in private jets to "save the climate". Making the working/middle-class poor..."you will own nothing & be happy". Making the poor radicalized & pointing their finger at each other.

This seems like a global scale psychological experiment more than anything. At some point the true believers in climate science will be disappointed by the contradictions of their heroes...because at the end of the day...it's about money & power. There is no "we". There is only "you will have to sacrifice so I can be more wealthy & hold more leverage over you".