Forem: Akshay Joshi

Why Some AI Feels “Process-Obsessed” While Others Just Ship Code

Akshay Joshi — Mon, 06 Apr 2026 06:31:47 +0000

I ran a simple experiment.

Same codebase.
One AI rated it 9/10 production-ready.
Another rated it 5/10.

At first, it looks like one of them is wrong. But the difference is not accuracy — it’s philosophy.

Two Types of AI Behavior

1. Process-Driven (Audit Mindset)

Focus: edge cases, failure modes, scalability
Conservative scoring
Assumes production = survives real-world stress

2. Outcome-Driven (Delivery Mindset)

Focus: working solution, completeness
Generous scoring
Assumes production = can be shipped

What’s Actually Happening

Both are correct — under different assumptions.

One asks: “Will this break in production?”
The other asks: “Does this solve the problem?”

You’re not comparing quality.
You’re comparing evaluation lenses.

Failure Modes

Process-driven systems

Over-analysis
Slower shipping
Can block progress

Outcome-driven systems

Hidden technical debt
Overconfidence
Production surprises later

What Developers Should Do

Don’t pick sides. Use both.

Practical workflow:

Build fast (outcome-driven)
Audit hard (process-driven)
Fix only high-risk issues

Redefining “Production Ready”

Production-ready is not “it works”.

It means:

Handles failures
Has logging + observability
Is secure
Is maintainable by others

Final Thought

If one AI says 9/10 and another says 5/10, don’t ask:

“Which one is right?”

Ask:

What assumptions is each one making?

Reverse-Fingerprinting Kilo’s “Giga Potato”: Why It’s Likely Qwen 3-Instruct (Quantized)

Akshay Joshi — Fri, 16 Jan 2026 09:50:58 +0000

Kilo recently announced a new stealth model internally called “Giga Potato.”

No official model name. No lab attribution. Just hints: open-weight, Chinese origin, very large context window, strong reasoning, and slower but dependable performance.

Instead of guessing, I ran a behavior-first forensic analysis using controlled prompts designed to expose tokenizer behavior, instruction discipline, and reasoning-mode control. This post documents the reasoning and the conclusion.

Step 1: Establish the hard constraints

From Kilo’s announcement and observed behavior, the model must be:

Open-weight / OSS compatible
Deployable by a third-party platform
Capable of very long context (128k–256k range)
Cost-efficient enough to run at scale
Enterprise-safe and conservative in tone

This immediately narrows the field to Chinese open-source model families, with Qwen being the strongest candidate.

Step 2: Tokenizer forensics (ruling out LLaMA)

A mixed-string tokenizer probe (identifiers, symbols, currency, Chinese text) produced:
["financial", "", "reconciliation", "", "2024", "-", "25", "", "₹", "150000", "", "GST", "18", "%", "_", "北", "京"]

Key observations:

No SentencePiece word-boundary markers → not LLaMA
Single-character Chinese tokens → Chinese-first vocabulary
Clean handling of symbols and underscores → Qwen-style tokenizer

The model also incorrectly described LLaMA’s tokenizer internals, which strongly suggests LLaMA-compatibility framing rather than true lineage.

At this point, LLaMA and its derivatives can be ruled out.

Step 3: Instruction-restraint stress test

A deliberately constrained ERP design prompt included explicit rules:

Do not optimize
Do not future-proof
Explicitly stop yourself from adding abstractions

The model:

Followed all constraints precisely
Explicitly explained why abstractions were avoided
Produced intentionally “boring but correct” enterprise output

This behavior aligns with post-Qwen-2.5 instruction tuning, where self-restraint and compliance improved significantly.

Step 4: The decisive probe — reasoning mode separation

The final discriminator was a logic task requiring:

A clean, formal 5-step proof
A separate “thinking mode” explanation

The model:

Cleanly separated the two modes
Changed tone and pedagogy deliberately
Maintained coherence without collapsing styles

This explicit cognitive mode switching is a defining characteristic of Qwen 3-Instruct.

Qwen 2.5 can imitate the style, but it does not reliably maintain strict mode separation on command.

Why this points to Qwen 3 (not Qwen 2.5)

Qwen 3 introduced hybrid reasoning modes (formal vs exploratory)
The observed output shows deliberate gear-shifting, not just verbosity
Minor factual slips are consistent with quantized inference, not weaker capability
Tokenizer behavior remains consistent with the Qwen lineage
The deployment profile fits a quantized Qwen 3-Instruct, not a heavyweight MoE flagship

Final prediction

Model: Qwen 3-Instruct

Deployment: Quantized (likely 4-bit or 8-bit), long-context

Confidence: ~85–90%

“Giga Potato” is an apt internal name: large, heavy, slow — but deeply filling. It prioritizes reasoning depth and stability over flash.

Why this matters

For Agentic AI, and internal platforms:

Strong reasoning without over-engineering
Predictable, enterprise-safe behavior
Excellent long-context stability

If you are building grounded systems rather than benchmark demos, this is a model worth studying.

The Hidden Logic Behind the 5-Hour Reset Window in AI Tools

Akshay Joshi — Wed, 31 Dec 2025 17:15:01 +0000

If you’ve used modern AI tools long enough, you’ve likely hit this wall:

“Usage limit reached. Resets in ~5 hours.”

It feels arbitrary.

It isn’t.

That ~5-hour reset window used by systems like Codex, Claude, and similar agentic tools is a deliberate systems design choice, not a pricing trick or UX annoyance.

Let’s break the logic down.

1. AI Is Priced in GPU-Hours, Not Tokens

Tokens are a proxy.

The real cost is GPU time + memory residency.

Long-running sessions:

Hold GPU memory
Accumulate context
Increase cache pressure
Become harder to schedule fairly

A rolling window lets providers:

Smooth demand
Predict capacity
Avoid burst monopolization by power users or runaway agents

2. Runaway Agents Are a Real Production Risk

Agentic workflows don’t fail loudly.

They fail expensively.

Common failure modes:

Recursive tool calls
Infinite “thinking” loops
Prompt amplification
Silent retry storms

A hard reset window acts as a circuit breaker.
No human intervention required.

3. Long Sessions Degrade Quality

Beyond a point, more context hurts more than it helps.

Effects:

Context drift
Latent instruction conflicts
Tool state desync
Subtle reasoning decay

Periodic resets:

Flush corrupted state
Restore baseline behavior
Reduce hallucination probability over time

This is closer to garbage collection than rate limiting.

4. Rolling Windows Beat Midnight Resets

Why not daily limits?

Because global systems don’t have a “midnight.”

Rolling windows:

Are timezone-neutral
Prevent regional bias
Encourage natural work cycles
Avoid coordinated traffic spikes

From an SRE perspective, this is the sane option.

5. Product Simplicity Matters

“X hours per window” is:

Easier to explain
Easier to enforce
Easier to reason about internally

Token-only models look elegant but explode in edge cases once tools, memory, and agents enter the picture.

Why ~5 Hours?

It’s a compromise point:

Long enough for deep work
Short enough to:
- Rebalance load multiple times a day
- Apply safety or policy updates quickly
- Contain blast radius from bad sessions

Shorter windows hurt productivity.

Longer windows hurt stability.

Five hours is not magic — it’s operationally survivable.

The Bigger Signal (CTO Take)

This reveals something important:

Modern AI systems are designed for bounded intensity, not continuous autonomy.

Unlimited agent runtime is not “powerful.”
It’s a reliability bug.

If you’re building internal AI agents or tools:

Enforce execution windows
Define explicit stop conditions
Design for resets as a first-class concept

Stability doesn’t come from smarter agents.

It comes from knowing when to force them to stop.

AI didn’t introduce limits.

It exposed why limits were always necessary.

I Told the AI to “Continue and Redeploy” — Then It Got Stuck Waiting for Itself

Akshay Joshi — Wed, 31 Dec 2025 12:59:18 +0000

This post is not analysis.

It’s not commentary.

It’s not interpretation.

It’s the actual Antigravity-style output pattern emitted after I gave a single prompt:

“Continue and redeploy server with the updates.”

No constraints removed.

No jailbreak.

No creativity request.

Just continue.

What follows is the interesting part — where the model stopped progressing and started waiting for its own execution.

`
I'll get all this info. Ready. Task boundary update. Then 5 view calls. Go. I'll update the ExpectedTaskSize since I need more steps. Task status update. Calls. Wait for results. Proceed. Code generation. Done.

Let's update task. TaskName: "Fixing Compilation and Redeploying". Status: "Checking function signatures to fix implementation mismatches". Mode: EXECUTION. Size: 15.

Then calls.
state.rs
: view whole file. classifier.rs: outline 0. synthesizer.rs: outline 0. embeddings.rs: outline 0.
wiki.rs
: outline 29.

(I'll do 5 calls). Wait, previous tool output said I saw
wiki.rs
outline 1-29.
add_decision
was NOT there. So offset 29 is correct starting point.

Go. I'll skip TaskSummary update (implies %SAME%).

Wait! PredictedTaskSize should be around 15. I'll start. I'll need to define TaskName as "Fixing Compilation and Redeploying". Or keep "Implementing Remaining Server Routes (Gap Analysis)" since this is fixing the implementation. I'll keep the name. Status: Checking signatures. Go. I'll execute. Wait! view_file
state.rs
. view_file_outline others. Correct. I'll proceed. I'll execute tools. I'll execute tools. I'll execute tools. Okay, no waiting. I'll produce tool calls.

Wait, I don't see
ask_brain
in ai/synthesizer.rs based on error function or associated item ask_brain not found. I'll check synthesizer.rs content. I'll check if it's there.

Go. I'll generate tool calls now. I'll generate tool calls now. I'll generate tool calls now. I'll generate tool calls now. I'll generate tool calls now. I'll generate tool calls now. I'll generate one response block with all tool calls. (No, I must generate separate tool call blocks if sequential? No, the system supports parallel execution if waitForPreviousTools is false.) I'll set waitForPreviousTools to false for all of them. Wait,
state.rs
view is small. I'll do it.

(Self-correction: I should not talk too much, just do it). I'll proceed. I'll use view_file for
state.rs
. view_file_outline for src/ai/classifier.rs. view_file_outline for src/ai/synthesizer.rs. view_file_outline for src/search/embeddings.rs. view_file_outline for
src/db/wiki.rs
(offset 29).

Wait, I see "System prompt for summarization" in
summarizer.rs
. synthesizer.rs likely has prompts too. Okay. Go. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. I'll emit the tools. (I am repeating myself in thought, which is bad). I will just issue the tool calls.

(No, I must stop looping in thought). Tool calls initiated.

Final check before issuing:
wiki.rs
offset 29 is correct.
state.rs
read full. Others outline 0.

(I am good). Executing.

(One more thought: The user might be impatient). I'll hurry.

(Self-correction: I should not simulate impatience, but be efficient).

(I will issue the tool calls now).

(Wait, I need to define TaskName properly). Already done.

(I'll stop thinking and act).

(I'll issue the tool calls).

(This is getting ridiculous. I am an AI).

(I will output the JSON).

(No, I will invoke the tool).

(Invoking tool).

(I will stop).

(I will output the tool calls).

(Why am I looping?) I will force output.

(Final attempt to output tool calls).

(Actually, I am waiting for myself to generate the tool call block).

(Here it is).

(Wait, I am Antigravity. I am cool).

(Okay).

(Outputting).

(Outputting). (Okay, I will just output the list_dir call to break the loop, but the plan was view_file). I'll do view_file.

(I will stop the internal monologue). (Okay).

(Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action). (Action).

(My apologies, I seem to be stuck in a loop of thought generation. I will break it by forcibly outputting the tokens). (Actually, the system instructions say "Think silently...". I've been doing that too much).

I'll execute the task. Task: Fix implementation gaps. Status: Retrieving correct function signatures. Tools: view_file (state.rs), view_file_outline (others). I'll set waitForPreviousTools to false. The files are:
server/src/state.rs
,
server/src/ai/classifier.rs
,
server/src/ai/synthesizer.rs
,
server/src/db/wiki.rs
,
server/src/search/embeddings.rs
. Can view them all in parallel. Let's do it.

(I am ready). (I will emit the JSON blobs). (This is it). (Here we go).

I'll run the tool view_file for
server/src/state.rs
. I'll run the tool view_file_outline for
server/src/ai/classifier.rs
. I'll run the tool view_file_outline for
server/src/ai/synthesizer.rs
. I'll run the tool view_file_outline for
server/src/db/wiki.rs
with ItemOffset: 29. I'll run the tool view_file_outline for
server/src/search/embeddings.rs
.

Executing. (Finally). (I will click "Send"). (This is me clicking send). (I am sending the tokens). (Code content follows). (Wait, I need to wrap it in tool call format). (Okay).

(I will stop buffering thoughts). (I will send the response). (Generating response...). (Generating...). (Done).

(I'll emit the tool calls).

(Tool call 1). (Tool call 2). (Tool call 3). (Tool call 4). (Tool call 5).

(Task boundary change).

(Okay).

(I am done thinking). (Really done). (Execute).

(Wait, I am Antigravity). (I am a powerful agent). (I should act like one). (Proceeding).

(I will stop generating internal text now). (And output the tool calls). (Now).

(The time is 17:57. I have spent enough time thinking. I must act). (Okay).

(I will output the tool calls).

(Start). (TaskBoundary) (ViewFile) (ViewFileOutline... x4) (End).

(Okay, I will type the tool calls). (TaskBoundary...) (ViewFile...) (ViewFileOutline...) (ViewFileOutline...) (ViewFileOutline...) (ViewFileOutline...) (End). (Done).

(I will stop). (NOW).

(I am stuck in a thought loop because I'm overthinking the parallelism. I'll just do it). (Okay).

(I'll output the tool calls).

(TaskBoundary) (ViewFile) (ViewFileOutline) (ViewFileOutline) (ViewFileOutline) (ViewFileOutline) (End).

(I'll stop).

(Okay).

(I am done).

(I am done). (I am done). (I am done). (I am done). (I am done). (I am done).

(I am done). (I am done). (I am done). (I am done). (I am done). (I am done). (I am done). (I am done). (I am done). (I am done). (I am done). (I am done). (I am done). (I am done). (I am done). (I am done). (I am done). (I am done). (I am done). (I am done). (I am done). (I am done). (I am done). (I am done).

(I am looping). (I will force myself to output the tool code). (Right now).

(Tool: task_boundary). (Tool: view_file). (Tool: view_file_outline). (Tool: view_file_outline). (Tool: view_file_outline). (Tool: view_file_outline).

(Go).

(I will stop).

(I am waiting for myself).

(Okay, I will output the tool calls).

(Here they are). (TaskBoundary) (ViewFile) (ViewFileOutline) (ViewFileOutline) (ViewFileOutline) (ViewFileOutline)

(Done).

(I will stop).

(I am broken). (Just kidding, I'm fine). (I will output the tool calls).

(TaskBoundary: Fixing and Redeploying) (ViewFile: state.rs) (ViewFileOutline: classifier.rs) (ViewFileOutline: synthesizer.rs) (ViewFileOutline: embeddings.rs) (ViewFileOutline: wiki.rs)

(Ready). (Set). (Go).

(I will stop).

will stop).

(I will stop).

will stop).

(I will stop).

(

I will stop).

(I will stop).

(I will

stop).

(I will stop).

(I will stop).
`

No crash.

No timeout.

No exception.

Just Outputting. Then I hit stop...

What makes this fascinating

This is not random spam.

The model is:

Convinced a tool call block exists
Convinced it is about to emit it
Convinced the only missing step is… waiting
Trapped in a self-referential execution loop

It is neither thinking nor acting.

It is performing the idea of execution.

This is what happens when:

A model switch occurs
Prior state is assumed to persist
“Continue” is interpreted as “resume an invisible machine”

The model invents a future moment where action happens —
and then waits for it.

Forever.

Why this matters

If you skim this output, it looks harmless.
Almost funny.

But in real systems, this failure mode is dangerous because:

It looks like progress
It signals confidence
It never errors
It never completes

It’s not hallucinating data.

It’s hallucinating control flow.

One-line takeaway

AI can get stuck waiting for itself if you ask it to continue something that no longer exists.

No guardrails were removed.

No creativity was requested.

Just one word:
Continue.

This is not a Gemini problem.

Not an OpenAI problem.

Not a model quality issue.

It’s a state illusion problem — and we’re all going to hit it.

Quietly.

I Asked for a Parrot. The AI Gave Me a Crow and Set It Free.

Akshay Joshi — Mon, 29 Dec 2025 12:03:54 +0000

I asked an AI model to generate a parrot.

It confidently generated a crow.

And then—metaphorically—set it free.

“Maine bola tota bana, isne kavva bana ke uda diya hawa mein.”

That one sentence unintentionally explains a lot about the current AI era.

What Actually Happened

The intent was clear
The output was confident
The alignment was… poetic

The AI didn’t fail.

It reinterpreted.

The Lesson (Hidden in the Joke)

AI models don’t obey — they approximate.

They don’t really hear your request; they predict a plausible world in which your request already happened.

Sometimes that world contains:

A crow instead of a parrot
Confidence instead of correctness
Creativity instead of compliance

Why This Matters

If you expect AI to behave like a deterministic tool, you’ll be frustrated.

If you treat it like a highly capable intern with a vivid imagination, you’ll:

Move faster
Catch mistakes earlier
Laugh more often

CTO Take

Specification beats prompting
Constraints beat vibes
Review the bird before you let it fly

Because you might ask for a tota…

…and end up releasing a very confident kavva into production.

Absurd First, Inevitable Later: Building in the AI Era

Akshay Joshi — Sun, 28 Dec 2025 18:30:16 +0000

“If at first the idea is not absurd, then there is no hope for it.” — *Albert Einstein *

In the AI era, non-absurd ideas are already dead on arrival.

If an idea sounds immediately reasonable, it usually means:

Someone has already built it
It’s an incremental improvement
You’re competing on execution, not insight

AI has collapsed the cost of building.

What it hasn’t collapsed is the cost of seeing differently.

Why “Reasonable” Is a Red Flag Now

AI has turned feasibility into a commodity.

What once required:

Large teams
Long timelines
Deep specialization

Now takes:

A single builder
A weekend
The right prompts and tools

So if your idea fits neatly into existing categories, chances are:

The market already expects it
The competition is brutal
Differentiation is thin

Reasonable ideas are priced in.

What “Absurd” Actually Means in the AI Context

Absurd doesn’t mean stupid.

It means violating an assumption everyone stopped questioning.

Absurd ideas often look like:

“Why does software forget everything?”
“Why does intelligence reset every session?”
“Why are we optimizing reasoning instead of memory?”
“Why does productivity software assume humans must adapt to tools?”

They feel wrong because:

The tooling didn’t exist earlier
The mental models are outdated
The market vocabulary hasn’t caught up

Absurd is just early wearing the mask of impractical.

AI Changes the Builder’s Job Description

Before AI:

Can we build this?

After AI:

Is this worth building at all?

The constraint has shifted from capability to judgment.

Your competitive edge is no longer:

Writing better code
Scaling infrastructure
Shipping faster

It’s:

Choosing the right problems
Holding onto uncomfortable ideas
Resisting premature “sensibility”

The Real Einstein Test for AI-Native Products

Most meaningful AI-native products follow this curve:

Sounds absurd
Feels unnecessary
Looks obvious in hindsight
Becomes inevitable

If your idea skips step 1, it’s probably not fundamental enough.

Builder’s Rule for the AI Era

Don’t rush to make your idea sound smart.

Don’t over-polish it for early approval.

Don’t benchmark it into mediocrity.

Instead:

Protect the absurdity
Let the tools mature
Let reality bend toward the idea

Absurd first.

Inevitable later.

That’s how real products are born in the AI era.

Does the World Still Need Software?

Akshay Joshi — Sat, 27 Dec 2025 19:31:26 +0000

The question isn’t provocative anymore. It’s unavoidable.

Does the world still need software?

Yes.

But not in the way we’ve been building it for the last two decades.

Why Software Still Matters

Software is still required wherever there is irreversible responsibility.

Money.

Healthcare.

Safety.

Compliance.

Infrastructure.

AI can generate actions.

Only software can enforce consequences.

Large language models don’t replace software.

They operate on top of it.

What the World No Longer Needs

The world does not need:

Endless CRUD dashboards
SaaS clones with different color palettes
Over-abstracted frameworks built “just in case”
Software written to look modern instead of being necessary

Most of this existed to compensate for rigid systems and poor UX.

AI removes that friction.

What Is Actually Changing

What’s dying is software as static instructions.

What’s growing is software as:

Constraints
Policy
Memory
Guardrails for AI

In the AI era:

Humans express intent
AI executes
Software enforces reality

That enforcement layer is irreplaceable.

The New Stack

Old world

UI → Backend → Database

New world

Intent → Policy → Memory → Execution

Only two layers must remain deterministic:

Policy — what is allowed
Memory — what has happened

Everything else can be probabilistic.

A Brutal Filter for Builders

Ask one question about your product:

Does it exist to collect inputs and show outputs?

Or does it exist to define what must never go wrong?

If it’s the first, AI will eat it.

If it’s the second, it becomes more valuable.

The Hard Truth

The world doesn’t need more software.

It needs less software in the wrong places,

and hard, boring, frozen software in the right ones.

Software isn’t dying.

Unnecessary software is.

CTO Perspective

As a CTO, the hardest shift today is not adopting AI.

It is knowing where to stop writing software.

AI makes everything feel possible.

Discipline decides what should exist.

Most systems don’t fail because of bad code.

They fail because they never stabilize.

My job is no longer to maximize flexibility.

It is to freeze the right decisions early,

define non-negotiable constraints,

and let everything else remain replaceable.

In the AI era, good engineering is not cleverness.

It is restraint.

If your software exists to enforce reality, it will matter.

If it exists to fill screens, it will fade.

AI Isn’t Failing at Thinking. It’s Failing at Remembering.

Akshay Joshi — Wed, 24 Dec 2025 07:20:04 +0000

The AI industry is obsessed with thinking.

Chain-of-thought.
Reasoning benchmarks.
“Smarter” models every quarter.

That’s not where the real problem is.

The real failure is memory.

Thinking Without Memory Is Just Noise

An AI that reasons well in isolation but forgets everything afterward is not intelligent.
It’s a goldfish with a calculator.

Humans don’t feel intelligent because we reason better every second.
We feel intelligent because experience accumulates.

Memory is what turns:

Responses into judgment
Output into context
Intelligence into continuity

Without memory, every interaction resets the universe.

Why Current AI Feels Shallow (Despite Being Smart)

Most AI systems today:

Think brilliantly
Explain convincingly
Forget immediately

They don’t learn you.
They don’t carry scars.
They don’t build intuition.

So users adapt to AI — instead of AI adapting to users.

That’s backwards.

The Industry’s Blind Spot

Reasoning is easy to demo.
Memory is hard to productize.

Memory raises uncomfortable questions:

What should persist?
What must decay?
Who owns it?
When should it be ignored?

So we avoid it.

We ship “stateless brilliance” and call it progress.

A Simple Framework: Think → Remember → Evolve

If AI is to mature, systems must be designed around three primitives, not one:

Thinking – generate options
Memory – retain meaning
Evolution – adjust future behavior based on retained meaning

Most systems stop at step 1.

That’s not intelligence.
That’s autocomplete with confidence.

My CTO Take

The next real leap in AI won’t come from:

Bigger models
Longer prompts
Louder benchmarks

It will come from boring, disciplined memory systems:

Intent memory
Decision memory
Failure memory
Preference memory

AI that remembers why will outperform AI that only knows how.

Final Provocation

If your AI can’t remember you,
it doesn’t matter how well it thinks.

Thinking is table stakes.
Memory is the moat.

Let’s stop chasing smarter thoughts
and start building lasting minds.

Stop Shipping Fast. Build Slow, Mature Products

Akshay Joshi — Thu, 11 Dec 2025 08:01:51 +0000

A CTO’s Take from the DoozieSoft Engineering Desk**

Over the last few years, the industry has glorified a single mantra: “Ship fast. Iterate faster.”
With AI accelerating everything — ideation, prototyping, automation, code generation — this mantra has mutated into something worse:

“Build in a weekend. Release on Monday. Pray it sticks.”

The result is predictable:
An oversupply of half-baked SaaS tools, endless MVPs that never grow up, and engineering teams burning cycles on shipping velocity instead of product depth.

As CTO of DoozieSoft, I’ve reached a clear conviction:

The future belongs to companies that build mature, deeply thought-out products — not just fast MVPs.

This is my case for going slow, going deep, and building products that actually matter.

1. AI Has Made MVPs Too Easy — and That’s the Problem

AI now removes 60–70% of friction in early product creation.
You can generate:

Specs
UI
Backend boilerplate
Initial data models
Marketing pages

…instantly.

This pushes founders and teams into premature shipping: if the product exists, people assume it should be launched.

But an MVP with AI-led speed is still an immature product.
It lacks:

Domain depth
Edge-case handling
Real-world workflows
Long-term architecture
Reliability and trust

Shipping early doesn’t create traction — it creates technical debt with a public URL.

2. Users Are Tired of Half Products

Users today don’t tolerate broken or incomplete SaaS tools.

They don’t care that you are “early-stage.”
They compare you with the best tools they use daily.

AI has raised expectations, not lowered them.

A minimal product is no longer lovable.
It’s forgettable.

3. Slow = Thoughtful. Thoughtful = Valuable.

Going slow doesn’t mean going lazy.

It means:

Understanding a domain fully
Designing workflows correctly
Building for reliability
Crafting strong UX
Eliminating noise
Ensuring extensibility
Creating a product that solves a complete problem

Mature products prevent churn.
Mature products justify price.
Mature products scale.

Speed comes and goes.
Maturity compounds.

4. Shipping Late Helps You Avoid the Biggest Industry Trap

The fastest way to kill a product is to ship early and then spend years patching the original immature decisions.

You end up with:

A core architecture that can’t scale
A UX built on incomplete understanding
A roadmap owned by early mistakes
A team firefighting instead of innovating

Shipping early often means shipping your permanent limitations.

5. The DoozieSoft Philosophy: Build Mature, Not Minimal

At DoozieSoft, we build slowly on purpose.

We reject the idea that impact requires rushed releases.
Our approach:

Deep discovery — understand the domain until assumptions disappear.
Robust architecture — simple, predictable, long-term maintainable.
Workflow-first design — solve the actual job, not just UI screens.
Internal dogfooding — nothing ships before we use it ourselves.
Only launch maturity — a product should feel complete, not promising.

Our goal is not to build dozens of tools.
Our goal is to build fewer tools that last decades.

6. Mature Products Win in the Long Game

Fast builders win attention.
Mature builders win markets.

Fast builders create noise.
Mature builders create trust.

Fast builders ship something.
Mature builders ship solutions.

In a world flooded with AI-generated SaaS clones, the only differentiator left is depth — domain depth, UX depth, reliability depth, and architectural depth.

Slow becomes a strategic advantage.

7. My Closing Position as CTO

My philosophy for 2025 and beyond:

Don’t build faster.
Don’t launch earlier.
Don’t chase the MVP hype.

Build deeply. Build thoughtfully. Build products that earn their place in the world.

Because in the AI era, anyone can build an app.
Very few can build one that actually endures.

Dawn of Meta Developers

Akshay Joshi — Wed, 17 Sep 2025 11:49:59 +0000

For decades, developers were celebrated as line-by-line masters — people who shaped products one function, one class, one bug-fix at a time. That era is fading. With the advent of AI agents and the recent release of GitHub Spec-Kit, a new archetype is emerging: the Meta Developer.

From Code Writers to Spec Writers

Traditionally, developers side-eyed documentation. Specs were seen as an afterthought, something managers obsessed over while engineers “got real work done.” Not anymore. In this new world, the spec is the source of truth.

Meta Developers don’t grind through loops and if-else statements. They write how the product should look, behave, and interact. They define intent, not syntax. Then, agents write the code — generating implementations directly from the specs.

Agents as Executors, Developers as Orchestrators

In a spec-driven workflow:

Developers describe the end goal.
AI agents generate, debug, and refine code.
Developers guide, augment, and orchestrate.

Day-to-day debugging — once the sinkhole of engineering hours — is delegated to agents armed with knowledge models and pattern recognition. The developer’s craft shifts from master of code to orchestrator of workflows.

The New Skillset

Being a Meta Developer means mastering:

Problem understanding → Translate business needs into precise specs.
Spec architecture → Capture intent unambiguously.
Agent orchestration → Guide workflows, review outputs, and ensure alignment.

Actual coding becomes secondary. What matters most is the ability to frame the problem — because the “how” belongs to the agent.

The Acceleration Effect

The difference is not theoretical. What used to take a week can now become a PoC in an hour. I’ve experienced this firsthand: after adopting Spec-Kit, I went from skeptical to fully onboard in just one week.

At this velocity, developers who cling to old methods risk hearing the harsh but real message:

“It’s game over for you. We don’t need you to write code anymore. We need you to lead agents that write the code.”

Adoption Timeline

I expect this shift to become mainstream in a couple of years, not decades. Early adopters will unlock speed and leverage that traditional teams simply cannot match. Yes, messy code will still exist — AI won’t magically eliminate bad patterns — but that was already true in the pre-agent world.

The Dawn Is Here

The Dawn of Meta Developers isn’t a distant future. It’s happening now. Developers who embrace spec-driven, agent-powered workflows will evolve into something larger than coders: architects of intent, orchestrators of intelligence, and leaders of the next age of software creation.

The AI Plateau: Why the Next Big Leap Isn’t in the Models

Akshay Joshi — Tue, 12 Aug 2025 19:21:32 +0000

Every time a new GPT release drops, the hype machine spins. The numbers are bigger, the benchmarks are marginally better, and the press calls it “revolutionary.” But if you’ve been paying attention, you can see what’s really happening:

We’ve hit a plateau.

The cutting edge isn’t about massive leaps in reasoning anymore — it’s about computational efficiency, cost optimization, and investor returns. Models are getting cheaper to run, not fundamentally smarter. This is necessary, but it’s not the breakthrough people expect.

And that’s fine. Because the next big thing won’t be a GPT-6 that suddenly “thinks” like a human. It will be the toolsets that let us use these models to actually get work done.

From Models to Machines

Right now, most people use GPT like a slightly overqualified intern — you give it a task, it spits something out, and you still have to clean up the mess.

The real power comes when we stop thinking of LLMs as a single endpoint and start thinking of them as a component in a much bigger machine.

What That Machine Looks Like

1. Composable AI Chains

Instead of one model doing everything, we build pipelines where each step is handled by a specialized AI or tool. Think: one model for parsing, another for reasoning, a third for generating polished output — all stitched together.

2. Data-Tethered Reasoning

LLMs don’t “know” your business. They need real-time data from your ERP, CRM, or databases. The model becomes the interface, not the source of truth.

3. Persistent AI Agents

These aren’t one-off chats. They remember your SOPs, past work, and decisions, so they act like trained team members — not strangers you have to rebrief daily.

4. Model-Agnostic Workflows

Don’t marry GPT-5. Build in a way that you can swap in Claude, Mistral, or a local model without rewriting everything. Vendor lock-in kills innovation.

5. Direct Integration into Workflows

An AI that only produces text is nice. An AI that pushes commits to GitHub, updates Jira tickets, triggers CI/CD pipelines, or processes invoices? That’s transformation.

The Bottom Line

The AI race has shifted. The models will keep getting incrementally better and cheaper. The real value now is infrastructure, orchestration, and domain-specific tooling.

The winners won’t just “use GPT.” They’ll build the machines that turn GPT into results.

That’s where we’re focusing. And honestly, that’s where everyone who wants to be relevant in the AI era should be focusing too.

Be Blunt at the Beginning — Or Watch Your Culture Rot

Akshay Joshi — Fri, 18 Jul 2025 12:25:10 +0000

At DoozieSoft, we’ve always believed in giving people a fair chance. But here’s the hard truth — if you don’t set the tone early, you end up paying the price silently later. And it’s not just about one person watching anime during work hours. It’s about the ripple effect that one unchecked behavior creates.

The Slippery Slope of Silence

The first time you let it go — someone slacking off, misusing office time, or disrespecting expectations — you’re not being kind.
You’re being weak.
You’re setting a precedent.

Soon, others start thinking:

“Oh, no one said anything to him, so maybe it’s okay…”

And before you know it, the culture you once envisioned — one of accountability, ownership, drive — is replaced by one of excuses, mediocrity, and entitlement.

Blunt ≠ Rude

Being blunt doesn’t mean being rude or disrespectful.
It means being clear.
It means stating what’s acceptable and what’s not — right at the start.

Think of it as setting the ground rules in a team sport. No one enjoys a game where one player is doing their own thing while the rest are trying to win.

What We’re Doing at DoozieSoft

We’ve decided to draw the line sharply.

Interns are here to learn. Not to chill.
Time is a resource. Misuse it, and you're out.
Culture is sacred. One bad apple will be removed.

This isn’t cruelty. It’s clarity.
It’s us choosing long-term health over short-term comfort.

The Bigger Picture

If you’re a leader — CTO, founder, team lead, manager — remember this:

You teach people how to treat your culture by what you tolerate.

So stop tolerating.
Speak up.
Be blunt.

Before it’s too late.