Ignite Bold Ideas, Faster

We fuse human ingenuity with AI to unleash limitless creative sparks. Are you ready to set yours on fire?

↓

The Craft Of Thinking

If you looked at the AI market right now, you could be forgiven for thinking there is only one serious thing an agent should do:

Write code. End of story.

Every week, a new coding agent appears. It refactors code, writes code, tests code, opens pull requests, spins up apps, and promises to make software production faster, cheaper, and a little more sleep-deprived. That is real progress. It is also, increasingly, a category error.

The industry is mistaking the most visible agent capability for the most important one. Coding is unusually seductive because it is legible, testable. You can benchmark it. Demo it. Screenshot it. Watch it produce a working artifact. Software velocity is easy to see, easy to measure, and easy to sell.

But code is not the end all be all of human expression.

And it is certainly not the end all be all of craft.

Craft begins earlier.

With thought.

Before there is software, there is an idea. Before there is implementation, there is framing. Before there is a system, there is a decision about what should exist, why it matters, what tradeoffs are acceptable, and what game is actually being played. Specification.

Craft follows thought.

Code does too.

That is the hypothesis behind APEx.

The Real Bottleneck Has Never Been Implementation

A lot of today’s AI discourse quietly assumes that if an agent can code, it can solve almost anything. That sounds clever until you ask a more annoying question:

How many important problems are actually code problems at the start?

Most are not.

Most are ambiguity problems.

  • What are we actually trying to do?
  • What problem matters most?
  • What changed?
  • What is stuck?
  • What option has leverage?
  • What is the right intervention here?

That is not coding work. That is cognitive work.

It’s the work upstream of software: strategy, framing, synthesis, prioritization, narrative, concept development, decision-making, creative direction. The work that produces a strategic brief, a product thesis, a recommendation, a roadmap, a pitch, a story architecture, a workshop scaffold, a sharper point of view.

And upstream work matters disproportionately, because the quality of implementation rarely exceeds the quality of the thinking that shaped it.

You can build the wrong thing beautifully.

Human beings do this all the time.

Code Is Powerful. It Is Also (Still) Expensive.

This is the other thing the market likes to forget.

Software is not just magic. It is commitment.

Every custom app brings a small parade of consequences behind it: auth, permissions, infrastructure, security, maintenance, observability, versioning, support, edge cases, updates, and the recurring joy of discovering that your elegant little solution now needs documentation, ownership, and a backup plan.

Sometimes that cost is absolutely worth paying. Sometimes software is the cleanest answer. If a workflow repeats often enough, touches enough users, or needs durable automation and reliability, then yes: absolutely build that thing!

But many problems do not need an app.

They need a better brief.

A clearer decision.

A stronger concept.

A sharper recommendation.

A more useful structure.

A more truthful frame.

Meet APEx

That is why we built APEx.

APEx (Ralph Wiggum Loop)

APEx is our new cognitive partner inside Ape Space, designed not to collapse every messy problem into an implementation task, but to help people work through the long middle of actual thinking: strategy, transformation, product development, creative writing, synthesis, reframing, direction-setting, and decision support. It is explicitly meant to drive the intelligence of the whitespace, not just answer prompts on command. 

It does not begin with, “What app should I build?”

It begins with, “What is actually going on here?”

Like in real life, that is often the more valuable question.

Because intelligence is not just the ability to produce an artifact. It is the ability to improve the quality of the intervention.

Sometimes that intervention is code.

More often it’s not.

OODA, Ralph, And The Refusal To Rush Ambiguity

Military strategist John Boyd developed one of the most powerful decision frameworks ever invented:

OODA – Observe » Orient » Decide » Act

The idea is simple: Winning in complex environments isn’t about perfect planning. It’s about fast, adaptive loops of understanding and action.

  • Observe the environment.
  • Orient yourself within it.
  • Decide the next move.
  • Act.

Then repeat.

Again. And again. And Again

The side that loops faster wins. This framework became the backbone of modern maneuver warfare. And now, one of the inspirations behind APEx.

The second inspiration is Ralph Wiggum.

Yes. That Ralph. The kid from The Simpsons who famously declares things like: “I’m in danger.”

Ralph has a very special way of thinking.

He tries things. They fail. He tries again. Things get weird. He tries again. And somehow — occasionally, mysteriously — something brilliant emerges from the chaos. This might not sound like a disciplined thinking method. But anyone who has ever worked on creative or strategic problems knows the truth:

Breakthrough thinking often looks like productive confusion.

Ideas collide.

Frames shift.

Assumptions collapse.

New patterns appear.

Ralph, unintentionally, captures something important about creativity:

You have to wiggum your way through uncertainty.

Under the hood, APEx is built on our own blend of OODA plus Ralph Wiggum: a loop that knows how to observe, orient, decide, and act, while also staying in motion long enough to handle uncertainty without panicking and turning every open question into premature certainty. As we put it in our latest release, APEx is optimized for “the kind of work most AI systems are still oddly bad at once things get messy.” 

That distinction matters.

Coding work usually benefits from clear constraints. Something runs or it does not. A test passes or it fails. Thinking work is different.

There is no compiler for strategy.

No linter for judgment.

No unit test for creative direction.

No passing build for whether a recommendation is politically intelligent, narratively coherent, and timed well enough to matter.

So the job is not deterministic execution alone. The job is structured exploration.

Observe.

Orient.

Decide.

Act.

Then loop again.

Not because ambiguity is a bug, but because ambiguity is often the raw material for bold ideas.

Why This Matters

This is not an anti-code argument.

It is a hierarchy argument.

Orient.

Decide.

Create the right artifact.

Then implement in code if warranted.

That sequence matters because code is one execution mode, not the definition of intelligence. The AI market is currently obsessed with agents that can produce implementations. We are more interested in agents that improve the quality of interventions. That is a different promise. We believe, AI should help people hold complexity, move through ambiguity, and build better things with more coherence and momentum. 

That is the lane APEx is built for.

Not to worship implementation, but to improve how we think.

At the layer where craft actually begins.

With thought.

What I Learned About The Value Of Human Work, After Months of Working With AI Coding Agents

I’ll start with a confession:

I was wrong.

Not about AI being powerful. It is.

Also, not about AI changing software work. It already has.

I was wrong about what kind of thing AI is. I assumed, at first, that AI might simply be “more intelligent” than humans in the way a crane is stronger than a person: bigger machine, faster output, same category.

After ~14 months of building with coding agents — shipping prototypes, breaking systems, rebuilding them, and moving from a locally run CLI toy into a real platform — I don’t think that anymore.

What I see now is this: AI is not a better human mind, it’s a different cognitive architecture all together. If you miss that, you will misread both AI and human work. A tiny lapse in reasoning, that sits underneath a lot of the current AI discourse. It’s also why “software is dead” hot takes sound clever on social media and then die the moment you need auth, billing, persistence, observability, or a system that still works on Tuesday.

Thesis 1: Clarity is kindness

The first thing coding agents taught me about human work: Clarity is not bureaucracy. Clarity is kindness.

Kindness to your team. Kindness to your future self.

Kindness to the machine you just asked to produce 5,000 lines of code before lunch.

LLM-based agents are wildly capable. But in their cognitive core, the LLM doing all the “thinking” churn, still operates as bursts of token throughput: tokens in, inference, tokens out. Let me be clear, in case there is any doubt: this is NOT how human brains work. Humans live in something else entirely: a continuous cognitive stream. We keep context alive across time (within the boundaries of our long-term and short-term memory). We carry intent. We revisit assumptions. We ask, nonstop:

  • Is this still the right direction?

  • What problem are we actually solving?

  • What are the non-goals?

  • Which constraint is real, and which one is just noise?

That loop is not overhead — we call it ‘inner monologue’, ‘strategic thinking’, ‘executive functions’. And however you want to call it: that loop is the work.

In long development sessions with coding agents, we’ve seen this pattern clearly reflected: what we are doing is often not “coding” per se. Coding agents have focused almost our entire developer time on doing directional labor:

  • defining scope

  • goals setting

  • non-goals definition

  • specs writing

  • requirements alignment

  • sequencing constraints

  • sharpening product intent

Yes, the AI can generate pieces of that. But it doesn’t have your intent. It doesn’t know your taste. It doesn’t know which compromise is acceptable and which one would quietly wreck the product six weeks from now.

This is not just an anecdotal founder rant. Anthropic’s 2025 internal study (132 engineers/researchers, 53 interviews, internal Claude Code usage data) found strong AI use for debugging and code understanding, with big self-reported productivity shifts — but also explicit concern about losing deep technical competence, weakening collaboration, and needing new approaches to learning and mentorship. They describe this as an early signal of broader societal transformation. 

That tracks exactly with what we’ve seen:

The agent can move fast.

It cannot care.

It’s the equivalent of a self-driving chainsaw. Human judgment is the only thing between your code and its teeth.

Thesis 2: Vibe architecture is no architecture

The funniest and most dangerous lie in AI right now is the idea that, because “vibe coding” can produce software, architecture no longer matters.

It matters more.

Coding agents can produce impressive looking output fast, and it was still the wrong move.

Our early version was a local CLI MVP. Great. Fast. Useful. Then we moved toward a real platform and the grown-up questions arrived immediately:

  • user identity

  • authentication

  • storage/persistence

  • billing

  • deployment strategy

  • infrastructure

  • observability

  • failure modes

That’s where many people discover: “generate app” is not the same ask as “design a system.”

It’s not that AI can’t help with these kinds of problems. It absolutely can. It can accelerate implementation and explore options quickly. But the truth is modern software development is a series of deliberate choices. If you don’t know the landscape,  if you don’t understand the option space, a coding agent will happily assist you as you “vibe code” yourself into a backdeadend you never meant to even build in the first place.

I’ve done it. Several times.

And that is not an AI failure. It’s a leadership failure. A product failure. An architecture failure.

The benchmarks are quietly saying the same thing. OpenAI’s SWE-Lancer benchmark used 1,400+ real freelance software tasks (including managerial decision tasks), and OpenAI explicitly reports that frontier models were still unable to solve the majority of tasks. METR’s randomized trial with experienced open-source developers on their own repos found that, in that setting, AI tool use made them 19% slower on average—even though the developers expected speedups. METR also stresses not to overgeneralize, but the result is a useful antidote to benchmark fantasy. 

That doesn’t mean AI is bad. It just means reality is large.

So yes, vibe coding is real. It’s useful, and it can be magical. But It is also often a speedrun into hidden complexity.

Vibe architecture is no architecture.

Thesis 3: Creativity does not come from abundance

The third thing coding agents taught me surprised me the most.

AI makes cognition feel abundant:

Need 20 implementation paths? Done.

Need 10 names? Done.

Need 4 refactor strategies? Done.

But creativity does not thrive in abundance. Innovation is born from scarcity. And creativity is innovation + relevance, optimized under utility constraints.

That last part matters: utility constraints.

A coding agent can be inventive. It can absolutely produce novel moves. But novelty is not creativity by itself. Creativity starts when someone makes a judgment:

  • this is the direction

  • these options are out

  • this tradeoff is worth it

  • this is elegant enough

  • this is useful enough

  • this is aligned

In other words: creativity is not just generation.

Creativity is selection under constraints.

And selection is painful. It means cutting away options, aying no. It means carrying the weight of taste, context, and accountability.

Machines are very good at generating options. Humans are still doing most of the meaningful reduction.

This is where the broader evidence is nuanced. The OECD’s 2025 review of experimental evidence summarizes real productivity gains (often 5% to 25%+ in the right tasks), especially when task fit is good — but also emphasizes that benefits depend on user skill, output evaluation, and proper use. They also flag a real risk: over-reliance can reduce independent thinking if people stop critically engaging with outputs. 

AI doesn’t eliminate the need for human judgment. It dramatically raises the cost of not having any.

This is not a software story, but a civilization story

If machines become abundant generators, then human value shifts upstream and downstream:

  • upstream: framing, intent, constraint design, ethics, taste

  • downstream: judgment, integration, accountability, consequences

You can see this in the current public discourse around coding roles: even people building agent tools are saying the center of gravity is moving from typing code to writing specs, defining intent, and talking to users. Boris Cherny, creator of Claude Code, said he expects major role shifts and more emphasis on spec work.  Stanford HAI’s expert predictions similarly point toward collaborative agent systems with humans providing high-level guidance — and note the growing pressure to prove real-world value, not just demos. 

And globally, the labor signal is neither utopian nor apocalyptic. The ILO’s 2025 update says one in four workers is in an occupation with some degree of GenAI exposure, but also emphasizes that most jobs are more likely to be transformed than eliminated, because human input remains necessary.  Meanwhile, the World Economic Forum’s 2025 digest says 39% of workers’ skills are expected to be transformed by 2030, with AI skills rising alongside creative thinking, resilience, leadership, and lifelong learning. 

That combination is the signal: Humanity is being re-specified, not replaced: Humanity is going to get itself one giant promotion — from working to leading. Leading armies of AI agents doing the work.

The danger is not (only) job loss. It’s skill atrophy, shallow thinking, and handing over too much judgment because the machine sounds fluent.

The opportunity is the opposite: teach people critical thinking, taste, rigor, ethics, architecture, and the discipline to choose. And the result will be a world where more people can build and thrive.

AI is changing what “being useful” means.

AI accelerates cognitive work. It does not make it any less tedious. If you want the upside without the chaos, you still need the “boring” things:

  • architecture

  • product thinking

  • systems design

  • constraints

  • taste

  • deliberate choice

Not sequentially. In parallel. All the time.

That’s the real lesson from 14 months of building with agents: the machine can do more of the work than I expected, and it has made human thinking more critical than ever.

Inconvenient for people who expected a shortcut.

Excellent news if you are in it to build.

—

Jo Wedenigg is the founder of Apes on fire, where he builds human x AI collaboration systems for creative, strategic, and transformation work. He is the creator of Ape Space and focuses on turning AI into a partner for advanced thinking.

 

 

 

 

 

 

Your Agent Is Just a Cron Job With a God Complex

2026 has already been dubbed the “Year of the Agent” — but not just by LinkedIn airball posts and X threads. A viral tool called OpenClaw (previously Moltbot/Clawdbot) has been making headlines for autonomously managing digital lives and spawning a full-on AI-only social network called Moltbook, where bots post, debate, and mimic social behavior without humans directly involved. And now, you can even follow the first AI Journalists on their own Substack.

Meanwhile Anthropic’s Claude Code rolled out longer-running session tasks that can coordinate multi-step workflows across time.  And in cybersecurity circles, researchers have been dissecting Moltbook’s rapid rise and even a major security flaw that exposed agent credentials — raising fresh questions about what “autonomy” really means in practice. 

Agents Are Software (And Why “Human” Is a Terrible Default)

Here’s the truth nobody’s selling you: agents are software. Period.

They run code. They follow control flow. They execute policies, read and write state, call tools, emit outputs. There is nothing mystical happening here but somewhere along the way, we started lying to ourselves.

We stopped saying “software” and started saying “agent.”
We stopped saying “program” and started saying “coworker.”
We stopped saying “automation” and started saying “autonomy.”

And with that shift, we quietly imported a dangerous assumption:

If it acts like a human, it must be better.

Let’s pause right there.

Humans are incredible.
Humans are creative.
Humans are adaptable.

Humans are also:

  • inconsistent
  • emotional
  • biased
  • forgetful
  • reactive
  • non-deterministic
  • sometimes just
 having a bad day

If we genuinely want agents to “act like humans,” then we don’t just get empathy and creativity — we also inherit bad vibes, erratic behavior, partial understanding, and mistakes.

Not because the software is bad. But because “human” is not an optimization target.

It’s a compromise.

The Hard Problems Are Human

Your “AI agent” is fundamentally a cron job with opinions — a while-loop that can hallucinate. Your agent doesn’t “decide” to do anything meaningful. It follows a probability distribution shaped by training data, system prompts, and temperature settings. When it succeeds, it’s because a human somewhere made good choices about what to optimize for. When it fails, it’s usually because those choices were implicit, unexamined, or wrong.

When we build agent systems, the industry loves to obsess over the easy stuff. Which LLM? What vector database? How many tools should it have access to? Should we use LangChain or roll our own framework?

This is intellectual theater. The hard problems aren’t technical — they’re human:

  • Deciding what actually matters
  • Judging quality when there’s no ground truth
  • Choosing between legitimate trade-offs
  • Setting direction when the path isn’t clear

Here’s the uncomfortable truth we discovered by actually running an always-on agent 24/7:

  • You don’t use it.
  • You manage it.
  • You onboard it.
  • You train it.
  • You correct it.
  • You set expectations.
  • You accept blind spots.

That’s not a tool relationship. That’s leadership. And leadership is cognitively expensive.

People already manage:

  • coworkers
  • managers
  • Slack threads
  • Jira tickets
  • family dynamics
  • their own internal chaos

The last thing they want is another quasi-human entity that needs supervision.

The industry calls this progress.

Most user call this work.

Autonomy Sounds Great – Until You Ask ‘For Whom’?

Let’s be precise about autonomy because the word has become meaningless through overuse.

Real autonomy is delegated execution within bounded constraints. It’s your agent retrying a failed job without waking you up at 3 AM. It’s polling a data source, summarizing logs, or surfacing anomalies for human review. The human set the goal. The human defined the boundaries. The software executed within those guardrails.

Fake autonomy is the absence of human intent dressed up as intelligence. It’s when your system makes choices nobody asked for, optimizes metrics nobody validated, or “decides” based on reasoning nobody can inspect. Fake autonomy isn’t agentic behavior — it’s organizational negligence.

On paper, autonomy sounds incredible:

  • General problem solving
  • Self-directed behavior
  • Minimal human involvement
  • Agents acting “on your behalf”

In practice, the most “autonomous” demos we keep seeing are
 revealing.

  • “It can sort through 10,000 emails!”
  • “We put 1,000 agents into a social network and watched what happened!”

Really?

That’s the bar?

We already failed at email.
We already failed at social networks.
We already built systems that amplify bias, conflict, and misinformation — with humans in the loop.

So here’s the question nobody wants to answer:

Why would software built in our likeness — with our biases and blind spots — perform better in those same systems?

If anything, it will fail faster.
Autonomy without judgment is just acceleration.
General problem solving without values is just noise.

The Real Black Box 

Here’s where things get subtle: Non-determinism isn’t actually the scary part. Humans are non-deterministic too. The real problem is role ambiguity.

Is this thing:

  • a tool?
  • a coworker?
  • a service?
  • a witness?
  • something that remembers me?
  • something that judges me?

Humans are excellent at social calibration when roles are clear. We’re terrible when they aren’t. That uncanny valley people feel with agents isn’t technical? It’s relational. We didn’t solve human unpredictability with explainability.

We solved it with:

  • social contracts
  • relationship scopes
  • interpersonal rituals
  • bounded responsibility
  • forgiveness

Trust isn’t built by saying “look how smart this is.”

Trust is built by knowing what it will not do.

Stop Worshipping Your Code

We name our agents. We give them personas. We say “the agent thinks” or “the agent wants” or “the agent decided.” This isn’t harmless fun — it’s a cognitive trap.

We are so eager to recreate ourselves in software — before we’ve even agreed that we’re a good reference design.

Maybe the future isn’t:

  • more autonomous agents
  • more generalized problem solvers
  • more human-like behavior

Maybe it’s something quieter, sharper, and more disciplined. Software that:

  • is explicit about its limits
  • is boring in the right ways
  • makes human judgment clearer, not optional
  • optimizes for intent, not imitation

Agents aren’t creatures. They’re tools with loops. Forgetting that is how you worship your own code instead of using it. It’s how you abdicate responsibility for decisions that should have human oversight. It’s how you end up with systems that “surprise” you in production in ways that aren’t surprising at all — they’re just unexamined.

The Boring Future We Need

2026 won’t be the year of the agent. It’ll be the year we finally stop pretending software is sentient and start building systems we can actually understand.

The best “agentic” systems won’t feel agentic at all. They’ll feel obvious. They’ll feel boring — in all the best ways. They’ll feel like what they are: well-designed software that does exactly what it was asked to do, shows its work, and knows when to ask for help.

Everything else is just a cron job with delusions of grandeur.

Why “Fully Autonomous” AI Agents Are a Fool’s Errand — And What We Build Instead

You keep hearing it: autonomous agents will take over tasks, free humans from drudgery, run entire businesses without supervision. It’s a seductive narrative. But in reality, full autonomy is a mirage — one often sold by marketers, not engineers. In this post, we argue that chasing full autonomy is not only impractical, it’s dangerous. The smarter bet is co-cognition: tightly controlled, collaborative AI systems that sit alongside human reasoning instead of trying to replace it.

(more…)

Forge

PUBLIC BETA COMING SOON

Forge is where you take your ideas from spark to impact – providing you all the tools to drive interactive, AI powered brainstormings, and breakthrough innovation sessions.

Rapid innovation and brainstorming

Lightning-fast ideation cycles that transform scattered thoughts into structured innovation frameworks.

Graph based idea management

Visualize connections between concepts with intuitive knowledge graphs that reveal hidden insights.

Contexts to add depth

Rich contextual layers that bring nuance and specificity to every creative exploration.

The tech inside the spark

We are building the platforms to work with whatever intelligence comes next

Thinking bigger at scale

We are building the platforms to work with whatever intelligence comes next

Where Innovation Takes Flight

Discover our big-picture outlook and see how Apes on fire is reshaping creative possibilities.