Got a call today but I didn’t answer it.

My iPhone screened it—then I read the transcript…

An automated billing system started talking to my iPhone 🤯

2 machines and neither knew the other wasn’t human.

I feel “smart-ish” I made this prediction about AI in 2022.

What is — Signals from the Field: My raw thoughts on going independent as a technical founder & builder using AI. When the signal hits, it hits your inbox—so you don’t have to wait for the full article.

Subscribe now

The Podcast Vibes

I was on someone’s podcast show in 2022, where we talked about frameworks, mental models and AI.

I didn’t know how AI worked internally the way I do now. But I said something I still remember:

I didn’t have a name for it but today it has one: A2A.

And today I experienced it in real time.

There are soo many businesses that are building today for a human—callers, visitors and customers.

I think that assumption is expired

A2A makes agent-to-agent communication a standard, not a custom integration anymore. Google and friends has picked it up and naturally many builders will use it for new systems.

When your customer’s agent calls your system, it will become natural for your system to respond from your agent—hopefully, it’ll notify you of what it did.

The businesses that implement these solutions now, won’t be scrambling when the volume picks up.

The call I got today—as an individual—was automated.

The one coming for your business will know what to say.

Do you know how your agent will respond?

What’s up, I’m Clint. Built software. Led teams. Now a founder helping builders who are ready to make the leap but can’t quite see the path yet. Every post is one conversation closer to clarity on ownership, execution and momentum. If you’re in that space, I’m easy to find

The Agentic World is here, it’s in our phones and computers

Are you using Agents?

Leave a comment

Just about 6 months ago I recorded a Fire Talk 🔥 Podcast episode and mentioned local AI, then recently I started clipping them and posting on social media.

I got the basic ~10 views, no likes. 😅

Then last week one of them crossed 1k views—I thought, how this one the others are better.

So, started a quick research and to my surprise.

We are all ready, now.

What is — Signals from the Field: My raw thoughts on going independent as a technical founder & builder using AI. When the signal hits, it hits your inbox—so you don’t have to wait for the full article.

Subscribe now

A Good Clip

I was trying hard to figure out which topics land.

What is interesting to me may not be interested to other builders or AI Enthusiast.

So, I clipped and post.

Then this one blew past up—for me this is blowing up lol

Just a mentioned of local AI, not a how-to or a product review. Just raw conversation about how people are using local models.

The clip did 1K views then sent me on a research trip.

Hugging Face and Ollama is blowing up, everyone is loving the security implication and token-saving angles.

I’ve been telling my fellow builders this is the way it go.

Now, I have validation.

Everyone is nervous about AI, yes it has speed and give a strong illusion of productivity. Adoption rates are really around security.

Then it became about tokenmaxxing.

Not about local vs cloud.

“How can I max my tokens and be secure while using AI?”

This now creates a new problem—well, question:

“What do I need to run local AI on my owned machines?”

With strong considerations for sensitive operations, IP-critical work, zero-trust environments, latency-dependent processes—all, because nothing can’t leave your network.

Then there’s a strong focus on speed vs trust in the cloud, where you have reach, scale, high-compute generation, anything that you can benefit from the latest bad-ass model version—regardless of platform.

With token costs are rising and Mythos making privacy requirements stronger.

Ollama and HuggingFace are the new App Stores.

Even just today, my outlook account sent me in a MFA Loop cause Microsoft tighten it’s security forcing you to change.

If the big platforms are trying to prove to you—small business and solo builders—that they’re secure enough.

Maybe, it’s because they don’t want you go local.

What’s up, I’m Clint. Built software. Led teams. Now a founder helping builders who are ready to make the leap but can’t quite see the path yet. Every post is one conversation closer to clarity on ownership, execution and momentum. If you’re in that space, I’m easy to find

Are you considering Local AI for your build?

Leave a comment

These 0-Day hacks are getting out of control.

Now, a disgruntled researcher posted their working exploit code to GitHub recently. It bypasses BitLocker—the encryption lock Microsoft ships on every Windows 11 machine—Just with a USB drive and 5min, boom 💥 access.

Think I’ll stay a Mac guy for now.

But we have to worry about our clients—they all still using windows.

What is — Signals from the Field: My raw thoughts on going independent as a technical founder & builder using AI. When the signal hits, it hits your inbox—so you don’t have to wait for the full article.

Subscribe now

Do We Still Trust BitLocker?

I used Windows for years, but man the troubleshooting, tweaking, building on it all was a pain.

I gradually I moved to Mac and only use windows for gaming—so, should I be concerned?

I have a client that use everything Windows—all workstations are Windows 11.

More than likely they have BitLocker.

This dude’s YellowKey breaks that in minutes + all from a USB drive in and a reboot in recovery mode.

Then they have shell access to files, passwords, certificates, browser data—all of it.

Then the bold move of just posting it live on GitHub, for anyone to follow the instructions.

Green hacking now, yellow hacking.

A full color-wheel of hacking coming next?

We spend all our time talking about AI prompt injection, LLM data leaks, AI-generated phishing.

The conversation we should be having is what if someone used AI to accelerate finding backdoor vulnerability, published the working code publicly, and now the expertise barrier to hack you is gone—oh it happened, mythos where are you?

BitLocker made a stolen laptop a non-event, but now anymore, Microsoft hasn’t even shipped a patch.

I hope my MAC don’t happen to get a PinkKey—haha. 🤣

What’s up, I’m Clint. Built software. Led teams. Now a founder helping builders who are ready to make the leap but can’t quite see the path yet. Every post is one conversation closer to clarity on ownership, execution and momentum. If you’re in that space, I’m easy to find

You should probably get that checked before you get stuck.

Are you concerned about BitLocker or
any of these Zero-Day hacks?

Leave a comment

So, I built an app for my client to help them run their books—reconciliation, ledger, the boring parts.

I added Claude—well, any cloud option—but local AI was my primary path. Goal: keep the data on the client’s machine, no subscription tax for the owner—win, right?

Nope….

What is — Signals from the Field: My raw thoughts on going independent as a technical founder & builder using AI. When the signal hits, it hits your inbox—so you don’t have to wait for the full article.

Subscribe now

The Hardware Stopped Me Before Claude Did

It’s been 2 months on my ledger app for a small business client. It runs clean on my Mac mini—everything is awesome!

I wanted to test local AI first, as the primary path—started with Qwen 2.5, 3GB.

But then I had to install on Windows Server 2016 😳, compiled the MSI, and…

Memory, good but cores? Not soo much.

CPU pegged on every run—100%.

Then Anthropic drops agents, together will do dances around LedgerGuide.

But I can’t blame them, the hardware stopped me first.

Are you betting on local AI or cloud models all the way?

I’m not alone, I’ve seen on social media that every time a builder ship something, a cloud foundation model ships a vertical—the crusher.

And this time they shipped my app—not the whole thing or even everything I’ve added, but a swarm of their Agents could probably do the job, better and faster.

We shouldn’t worry too much tho…

What they shipped is for BMO and Amalgamated Bank—all enterprise pricing. However, what they didn’t ship—yet—is the small business owner running QuickBooks at 9pm trying to figure out why two transactions don’t match.

Now, I guess it’s time to add the optional feature already scaffolded.

Add your Anthropic or OpenAI API key—😊

For the hardware issue for local—I found a way. 😜

We got this…

What’s up, I’m Clint. Built software. Led teams. Now a founder helping builders who are ready to make the leap but can’t quite see the path yet. Every post is one conversation closer to clarity on ownership, execution and momentum. If you’re in that space, I’m easy to find

If you’ve shipped something this year that competes with a Anthropic, OpenAI or any of the Big-Tech models.

Do you have a plan?

What is your workaround to handle this?

Leave a comment

I’m learning…

So, I went under the hood to build my own agent harness—we can argue about “harness” definitions later.

What I found broke my mental model of how these AI conversations actually work.

Then I went deeper, into the rabbit hole and I landed on a new way to save tokens and communicate like a caveman.

What is — Signals from the Field: My raw thoughts on going independent as a technical founder & builder using AI. When the signal hits, it hits your inbox—so you don’t have to wait for the full article.

Subscribe now

What’s Actually Happening Under the Hood

Everyone, from solo builders, enterprises and AI platforms are all building agents. The definition moved from “one bad ass prompt” to an autonomous orchestration that still include prompts, scripts and automation—so, started a tiny project to understand them even more.

I built one from scratch using local models, local machine—assuming full control.

Here’s what I learned:

Models are stateless. Every single conversation, every MCP request, every RAG chunk you load will all get sent again from the beginning as a precursor to every new message.

All of it—just to ask something as simple as “how are you doing today?”

When that’s built well, it feels seamless.

But when it’s not, OMG, that’s when the hallucinations begins.

Then what about existing harnesses, which is good which should I be using?

So deeper I go, found OpenCode, a whole bunch of talk about Claude Code—then it leaked.

Then I found Letta!

I haven’t tried it yet. I’m working on one thing at a time and I have a full queue. But this one’s on the list for sure.

I also learned that the model gets all the attention, while the harness is where the magic happens.

If you’re like me and working with multiple AI models—local or public—and you want good memory management for your context, Letta is #1.

The desktop wars is about who owns the interface.

The harness war is about who owns the memory.

…and guess what?

right now, the open-source option is winning on benchmarks.

I’m going to try Letta.

If you’re already running it

How about you?

What’s up, I’m Clint. Built software. Led teams. Now a founder helping builders who are ready to make the leap but can’t quite see the path yet. Every post is one conversation closer to clarity on ownership, execution and momentum.

It’s really about the AI Agent and the power of
using AI on your desktop

Read More On Desktop Wars

Research

• https://www.letta.com/blog/letta-code

• https://github.com/letta-ai/letta

• https://www.letta.com/blog/introducing-the-letta-code-app

• https://github.com/breakbottle/c-ai-agent

How Do You Work?

If you’re coding or vibe coding, you’ll have many avenues and levels to manage—with one goal in mind.

To ship—a problem to be solved with this shipped solution.

My problem was running between Notion, Freecamp, and Google Workspace, drowning in tabs and feeling burn out—context switching like crazy.

I got a brilliant idea—it felt smart, lol.

So, I built my own Project/Tasks Management tool to match how I work.

Everyone has a pattern they follow when they execute work—from building, writing, just work—it’s there version of “I have a system for that”

This was my system that came to life in a tool.

Subscribe now

What’s up, I’m Clint. Built software. Led teams. Now a founder helping builders who are ready to make the leap but can’t quite see the path yet. Every post is one conversation closer to clarity on ownership, execution and momentum.

I called it Personal PM Flow

This was my first test using Antigravity—Googles answer to Cursor, Codex and Claude.

I described what I needed, and it gave me back something I didn’t ask for—a multi-user, cloud-connected, fully authenticated project management system with role-based access control.

That’s what AI does when you don’t tell it what phase you’re in—it was just scaffolded code and nothing really worked anyways.

It builds for the dream, not the now.

I pushed back—hard.

Then what came out of frustration of back-and-forth, is what built the foundation for what I actually shipped, use every day now.

I learned something that changed how I approach building:

So, figure I’ll share every major decision, the tradeoff I accepted, and the pitfall I hit along the way.

The How I Work Context Problem

When I described Personal PM Flow to the AI, I said something like:

“I need a project management app to track my tasks, log my time, and help me avoid burnout. I want workspaces, projects, tasks, and a timer.”

What came back: a schema with a users table, JWT auth, a REST API with protected routes, a cloud database connection, and a settings table with user-scoped preferences—it was scoped, but not everything was connected.

All of this is technically correct for an enterprise app but what I needed was something simpler.

AI was building for the product I might want someday, but I really just needed the product that would work this week on my machine, for 1 person—me.

The fix included explaining how I work + why + and expanded prompt—the prompt eventually was built from more back-and-forth and ended up more closer like this:

“I’m a consultant, fractional CTO, forward deploy engineer that sits on client’s team. I need to track my time, and manage my work on 4 levels—workspaces, projects, tasks, & checklist. I’m forced to switch between client work daily, so timer must be seamless transition, I need reporting for my time card. This is local only, single user, no auth needed yet, and most importantly I need this to help me manage my burnout, motivational queues but also a workday limit and barriers to stop. also, I need to use this tomorrow”

The output was now very different and gave me that foundation to what actually shipped.

The Ups and Downs

Here’s what the AI wanted to give me:

[Users] → [Workspaces] → [Projects] → [Tasks]
    ↓           ↓              ↓           ↓
  auth        roles         members    assignees

Here’s what I actually needed:

[Workspace]
    └── [Project] or [Program]
            └── [Task]
                  ├── [Checklist Items]
                  ├── [Time Entries]
                  └── [Recurring Cadence]

I just needed one user, no roles, no assignees.

Just a simple hierarchy, time, and behavior.

It still wasn’t perfect, some early decisions didn’t make it in:

I started with 3 task statuses instead of 2.

AI gave me open and done. I pushed back—I needed deferred.

Because I know myself—I don’t like delete; I’ll almost always archive first and when it came to tasks I hadn’t gotten to. I needed a place to park them.

Pitfall I hit: I didn’t add deferred to the schema until v0.6.0—after I’d already archived a project and watched all its open tasks get marked done when they weren’t.

That was wrong—archive now moves open tasks to deferred, not done.

SQLite and Why I Had to Fight for It

AI’s first suggestion was Postgres—always Postgres.

Nothing is wrong with Postgres it’s ok.

But when I said local-first, single user, runs on my laptop—I expected SQLite.

A simple 1 file, no connection pool, no server process, no major configs—my data is literally a file on my machine.

Phase 1 reality:          What AI wanted to give me:
─────────────────         ──────────────────────────
1 user                    Multi-user ready
Local machine             Cloud-hosted
Zero infra                Managed Postgres
Ship this week            "Future-proof" from day 1

My pushback:

“I don’t have concurrent users, I don’t have a server, I have a Mac-Mini. Just give me SQLite.”

SQLite’s synchronous driver can block the event loop under concurrent load and for one person using one app, that never surfaces.

When I’m ready to scale this as a real product with real users, I’ll swap to Postgres—I won’t have to worry about the schema or queries.

Pitfall I hit: No WAL mode enabled on first boot—WAL (Write-Ahead Logging) reduces corruption risk under power failures. I learned this when I asked AI to challenge my implementation details, which allowed me to add it later.

I learned this is something that shouldn’t been skipped as it should have been the first pragma set on database init.

Server Actions vs. REST

The ROADMAP for MVP0 says “API routes.”

So, that’s what I built first but then had to replace it:

REST approach (what I started with):
UI Click → fetch('/api/tasks/start-timer') → API Route → Service → DB → Response → UI update

Server Actions approach (what I ship with):
UI Click → startTimer(taskId) → Server → Service → DB → Page revalidates

By trying to add Server Actions in the beginning but that collapsed the API contract entirely.

There were no endpoint to build, no serialization layer to debug or auth token to pass in.

The function lives on the server and all I had to do is call it from the client locally, then Next.js handles the rest.

For a solo builder with one frontend and no mobile app yet, I think this was a good decision—it’s just moving data around.

If—when—I want a mobile app or external integration, I’ll need to extract a real API.

I deferred that work—it’s in my roadmap at MVP5 and MVP6.

Pitfall I hit: Early on I put business logic directly in the Server Actions instead of a service layer—It felt faster. Can’t test a Server Action in isolation—it was wired to the Next.js runtime. I had to have AI refactor everything into service files.

The Architecture Layers

┌─────────────────────────────────┐
│         UI Layer                │  Next.js pages, React components
│  (Server Components + Client)   │  Vanilla CSS — no Tailwind
├─────────────────────────────────┤
│       Server Actions            │  Mutations: create, update, delete
│   (app/actions/*.ts)            │  Revalidate the page on completion
├─────────────────────────────────┤
│       Service Layer             │  Business logic — no Next.js here
│   (lib/services/*.ts)           │  TimerService, BurnoutService, etc.
├─────────────────────────────────┤
│       Database Layer            │  SQLite via better-sqlite3
│   (db/index.ts + pmflow.db)     │  Synchronous, local, one file
└─────────────────────────────────┘

Each layer only talks to the layer below it.

• UI talks to Actions

• Actions talk to Services

• Services talk to the DB

Nothing skips a layer, this matters because I vibe coded fast and messy in the beginning—and the errors was ugly.

The layer separation kept it from becoming a pile of dudu. 💩

Now when something breaks, I know exactly which layer to have AI look at.

Pitfall I hit: AI choose Tailwind for CSS, I pushed back. For a solo builder building a personal tool, utility classes add visual noise to a codebase you’re already reading at speed. Vanilla CSS was the best choice here.

Managing Burnout

The burnout feature was a late MVP1 addition—it seems that when I first described it to AI, it gave me a frontend-only solution: a JavaScript only timer that tracked hours in the browser, fired an alert and reset on page refresh.

That’s a notification you can ignore by refreshing the page—I wanted it tighter

“This needs to be in the database, I want to know how many times I’ve dismissed the alert to track in a report.”

What AI gave me first:          What I shipped:
──────────────────────          ───────────────
JS counter in browser           burnout_events table in SQLite
Resets on refresh               Persisted forever
No history                      Logs every overage + snooze
No reporting                    Weekly report shows the pattern

The burnout_events table logs every time I hit my daily limit and every time I dismissed it.

When I ran my first weekly report and saw 78 hours, I couldn’t argue with my own database.

That’s different from a notification you can swipe away, right?

Pitfall I hit: The first burnout alert had no escalation at all, it only fired once, you dismissed it, then it was gone. I added a soft alert first, then a hard block. The hard block forces you to pause the timer.

My CHANGELOG.MD

Most changelogs are for users—maybe teams. Mine is just for me—a record of every time I got something wrong and fixed it.

Here’s some callout of my corrections:

• 0.6.0 — Archive moves tasks to deferred, not done. I got the behavioral model wrong first.

• 0.7.1 — Delete blocked when a child timer is active. I broke data integrity before I added this guard.

• 0.8.2 — Daily stats now use timezone bucketing. Late-night UTC rows were inflating my “today” hours. Took until 0.8.2 to catch it.

• 0.8.3 — Focus Mode scope was snapping back to stale project context. Atomic updates fixed it.

Every one of those was a real failure point, it came with frustrations and times feeling stuck.

Now, while using the app daily—if I encounter a potential feature or non-blocking bug—I add it to my backlog and is tracked in changelog when it’s implemented.

The Living Roadmap

MVP0  ✅  Core infrastructure — schema, timer, carryover, reporting
MVP1  ✅  Daily usability — burnout, focus mode, recurring tasks, break logging
MVP2  ⬜  Task & project mobility — duplication, bulk actions
MVP3  ⬜  Reporting intelligence — estimates vs actuals, CSV export
MVP4  ⬜  Notifications — reminders, auto carryover
MVP5  ⬜  Integrations — Google/Outlook calendar (read-only)
MVP6  ⬜  Multi-device — sync, backup + restore UI

A scope contract I made with myself.

When AI suggested building calendar sync in MVP0, I said no—even to AI agent integration.

Every shiny feature that isn’t in the current MVP is in the backlog.

The foundation is clean enough to support all of it.

SQLite becomes Postgres when the user count justifies it.

Server Actions get an API layer when mobile needs it.

But right now, none of that is the constraint—it’s shipped and being used—daily.

I solved my problem of switching between Notion, Freecamp, and Google Workspace, and other tools in my daily work.

The 3 Decisions That Will Always Slow You Down

1. Choosing your database before you know your user count. SQLite for one. Postgres for many. The mistake is using Postgres for one because you might have many someday. You’re paying a complexity tax on a future that may never arrive.

2. Building the API before you know your clients. If your only client is a web app you’re building yourself, you don’t need a REST API yet. Server Actions get you to working software faster. The API comes when a second client requirements is mobile, needs integration, or 3-party requirements actually exists.

3. Letting AI design for scale you don’t have. AI is trained on production systems. It defaults to patterns that handle millions of users, multiple services, and complex auth. When you’re building phase 1 for yourself—or just small—that’s wrong almost every time. The most important thing you can put in your prompt is the constraint: what this does NOT need to do yet.

The Pitfalls That Will Find You Anyway

• No WAL mode on SQLite init: add it immediately, not later

• Business logic in the wrong layer: it always costs more to move it than to place it right the first time

• Behavioral modeling after schema design: know how the app will be used before you design the tables

• Over-trusting the first AI response: the first answer is the general answer, not your answer. Push back with your constraints.

Do you have a simple project that AI is making complex?

The builders who ship phase 1 aren’t the ones with the best architecture at all. They’re the ones who learned from the grind of many mistakes, pitfalls and finally land on the right-sized architecture for the problem they’re solving.

The next time AI gives you a multi-user, cloud-connected, fully authenticated system for a personal tool or small tool—I give you permission to push back.

What phase are you in?

Leave a comment

Research Notes

1. Local-First Software: You Own Your Data, In Spite of the Cloud — Ink & Switch (Kleppmann et al., 2019)

2. Appropriate Uses For SQLite — SQLite.org

3. Using SQLite in Production — Drifting Ruby

4. Do Things That Don’t Scale — Paul Graham

5. Top Five Causes of Scope Creep — Larson & Larson, PMI

6. Regression Testing Guide — Reflect.run

OpenClaw hit 247,000 GitHub stars in 60 days, then anyone who builds, download and ran toward it.

A number like that number wouldn’t go unnoticed—then the hype began.

Three weeks later Claude Desktop expanded.

Then OpenAI planned to drop Codex with Computer Use.

Now Gemini has a native desktop app—and probably by the time I post this, Codex desktop upgrades would be live.

This wasn’t a coincidence.

OpenClaw rang the bell and every major AI company didn’t want to get left behind.

What is — Signals from the Field: My raw thoughts on going independent as a technical founder & builder using AI. When the signal hits, it hits your inbox—so you don’t have to wait for the full article.

Subscribe now

The Open-Source Warning Shot

I’ve been watching OpenClaw from the sidelines.

Builders I collaborate with are all over it—experimenting and sharing their pitfalls.

Think of that power—an AI that runs on your own hardware, connects to your apps, executes tasks autonomously—no SaaS, no corporate server in the loop, no subscription required, you host & manage it.

To put OpenClaw in context of how fast it gained popularity; React—a coding lib, by facebook—took about 10 years to reach that number.

OpenClaw proved to big-tech that the demand for this type of application was needed.

Anthropic reacted first and started internally planning, then the creator of OpenClaw joined OpenAI in February.

…and every AI company suddenly had the same roadmap.

Why were builders so hungry for something they had to host themselves?

All of these companies are putting the control right in your hands—and that’s by design.

You feel powerful, you can do so much more.

But what is the tradeoff?

What are you giving up for this?

When Gemini floats over your screen and reads your local files, that data is moving through Google’s infrastructure.

When Codex works in the background on your computer to click through your applications, OpenAI’s model is watching your session.

That is your privacy you’re giving away—especially if you’re a business owner with client data, proprietary code, or financials living on that machine.

OpenClaw started as the builder’s version, now this is exactly what these companies are now selling.

The difference is where the data goes and who makes the rules.

It’s clear for solo, but if you’re leading a team and your developers are about to start running AI desktop agents on their work machines—now, AI can learn from their habits.

Some can label this as a path towards replacing developers entirely, while others see this as a deep peek into stealing their IP—another breach coming.

What would you be comfortable letting it see?

What’s up, I’m Clint. Built software. Led teams. Now a founder helping builders who are ready to make the leap but can’t quite see the path yet. Every post is one conversation closer to clarity on ownership, execution and momentum.

The AI is moving fast. If you're building on shifting ground and need a second opinion on your tech stack, let’s do a:

Clarity Session

Research

• https://github.com/openclaw/openclaw

• https://www.kdnuggets.com/openclaw-explained-the-free-ai-agent-tool-going-viral-already-in-2026

• https://openai.com/index/introducing-the-codex-app/

I came home, opened my terminal, open Claude and my Spindle /buddy was gone.

No snarky remarks or tips

Just gone!

It was a short relationship. I still miss it.

What is — Signals from the Field: My raw thoughts on going independent as a technical founder & builder using AI. When the signal hits, it hits your inbox—so you don’t have to wait for the full article.

Subscribe now

RIP Spindle — My /buddy

Claude Buddy is an April Fools joke that got me.

You get a terminal pet for about 18 species, 5 rarities & mine was a capybara named Spindle.

High SNARK stats.

It would roast my architecture choices—and writing, but would drop tips mid-session.

It felt real—more useful than I expected.

Then one day it was gone.

Spindle, just gone.😭

I didn’t need a terminal pet. And yet.

It kinda changed the feeling of building alone.

I mean, Anthropic built a toy as an easter egg and accidentally solved something real.

Do they even know it?

So, I did some digging and I wasn’t the only person that feels this way, it turns out the community built is back: https://github.com/1270011/claude-buddy

This is your chance to try it!

What’s up, I’m Clint. Built software. Led teams. Now a founder helping builders who are ready to make the leap but can’t quite see the path yet. Every post is one conversation closer to clarity on ownership, execution and momentum.

The AI is moving fast.
If you wants some tips with your terminal,
let’s do a:

Session

I saw a post about ‘caveman’ prompting to save you tokens.

So, I figured I give it a try—wow—2 words in and AI understood me.

A shorter response, less noise and straight to the point. That got me thinking…

Should I use it, more? 🤔

What is — Signals from the Field: My raw thoughts on going independent as a technical founder & builder using AI. When the signal hits, it hits your inbox—so you don’t have to wait for the full article.

Subscribe now

Token Economics

I’m long-winded—I like to explain and sometimes I over-explain.

I do the same with AI, Full sentences—but with bad grammar, spelin & punctuation. 😄

I try to provide good context and details in my prompts. I assume that’s how you got better answers.

Then when I tried caveman mode, the context was still there and sometimes better answers.

It was only a test but if a detailed prompt gives you detailed insight, does a short prompt give you a short answer without the insight?

I mean, if it saves tokens then why not use it, right?

If you train yourself to communicate in short, stripped-down bursts with AI every day, does that habit follow you into real conversations?

I think so!

The way you speak to anything consistently is the way you build the habit of speaking. You practice short, you get short.

That’s ok for prompts. Not sure it’s fine for people, tho.

Caveman prompting might save your token budget. Just make sure it doesn’t accidentally become your communication style with humans.

What you think, you gonna use it?

What’s up, I’m Clint. Built software. Led teams. Now a founder helping builders who are ready to make the leap but can’t quite see the path yet. Every post is one conversation closer to clarity on ownership, execution and momentum.

The AI is moving fast.
If you’re building with AI and need some new eyes
on your project, let’s do a

Schedule

We were waiting patiently, using up all our tokens on Opus 4.6—this thing was already impressive.

But the promise of a new model kept us asking: What could possibly come next?

Anthropic teased Mythos and that got us excited.

Then they released it

Kinda—then pulled it back in the same breath.

What is — Signals from the Field: My raw thoughts on going independent as a technical founder & builder using AI. When the signal hits, it hits your inbox—so you don’t have to wait for the full article.

Subscribe now

They Used “wing” In The Name 😊

I was recording a new podcast episode yesterday, aiming to talk about how AI can do good in the world.

We couldn’t get through a single topic without Glasswing (Mythos) coming back up.

Energy? Someone can weaponize it

Healthcare? Same.

Every positive use case lives right next to a very dark one.

Someone posted about it on notes and I couldn’t help but comment a reference to Lord of the Rings’s “precious” 💍

I guess it’s all about that “precious” power!

This all started with Tokens and leverage.

New says for the first time in 7 years a leading AI lab withheld a model over safety concerns. - TechCrunch

OpenAI now have massive leverage with the government as Antropic biggest competitor.

So, when they determined that Mythos found thousands of zero-day vulnerabilities across every major Operating System and browser in weeks—including A 28-year-old OpenBSD flaw. Boom!

Lock it!

You build the most powerful thing in ever and immediately the question isn’t how do we use it.

It is: who gets to hold it—let the negotiation begin.

Maybe we got hood winked?

I mean, what stops OpenAI, Google, or any other lab from doing the same? Sitting on their most capable model while enterprise pays for the edge and continue to squeeze the small man?

I’ll tell you, nothing,

Nothing at all.

This is the big shift.

Big platforms holding the real power, the market, the tools and all your tokens 😂

What are you keeping your eye on?

What’s up, I’m Clint. Built software. Led teams. Now a founder helping builders who are ready to make the leap but can’t quite see the path yet. Every post is one conversation closer to clarity on ownership, execution and momentum.

The AI is moving fast.
If you’re building with AI security concerns,
let’s do a:

Schedule Diagnostic Session

OMG, 2 leaks dropped back to back both from Anthropic, what???

And now, we have their roadmap—ouuu, hahah 🧛🏽‍♂️

The clones are coming, you can’t un-ring this bell.

Do you think this is good competition or ?

What is — Signals from the Field: My raw thoughts on going independent as a technical founder & builder using AI. When the signal hits, it hits your inbox—so you don’t have to wait for the full article.

Subscribe now

From ClaudeCode to OpenCode.

The big players continue to dominate with Claude dropping feature after feature. OpenAI cooking, Google making deals, Apple embedding on mobile, social media platforms tightening their algos, X’s Grok doing what Grok does and honestly, still can’t tell what Microsoft Copilot is up to.

They’re big tech because they’re in the lead and they have the resources to stay there.

But now they’re all being threatened by the likes of OpenClaw—you know, the xClaw era is here.

And with these leaks, tools like OpenCode could this finally level the playing field for new players.

Maybe?

A week before the leak I stumbled on this open source project, it looked cool so I tried it.

Their pitch: don’t want to pay $20/month? we got you at $10 & right now it’s $5 on discount.

My first run—I loved it.

One interface for Zen model, Claude, GPT, Gemini, local models, all in one place.

The thing I like most?

Their community is genuinely focused on security and it’s a perfect sandbox for testing downloaded models.

What I’m watching—as they’re not established yet—is they’re training on your data during the discount period. This is what their docs say—but we’ll see.

But for builders who want flexibility without the subscription anxiety? Cheaper Tokens?

It could be worth a serious look.

What’s up, I’m Clint. Built software. Led teams. Now a founder helping builders who are ready to make the leap but can’t quite see the path yet. Every post is one conversation closer to clarity on ownership, execution and momentum.

The AI is moving fast.
If you’re building and want a second opinion on your tech stack, let’s do a:

Schedule Diagnostic Session

I’ve been glued to Claude’s status page ever since the Gov’t swapped their contract for OpenAI.

It’s been some ups & downs, and some good days, but today is all “elevated errors” and “connection resets”.

Have you noticed?

What is — Signals from the Field: My raw thoughts on going independent as a technical founder & builder using AI. When the signal hits, it hits your inbox—so you don’t have to wait for the full article.

Subscribe now

1M Context Window Or Outage?

Yesterday, I was about 4 hrs deep into a session, building, validating test cases, making sure the feature was tight.

Claude was nodding along, “yep”, “you’re good”, but the execution was trash. It stopped following all the rules I set at the start.

I hit a wall, killed the thread, and started a fresh session.

Boom. It worked

Was the solutions a fresh thread or an actual outage?

We’re told these models have massive memory, but they actually “compact” the conversation behind the scenes. Every time I see “0% before we compact conversation” I panic!

They’re basically lobotomizing your logic to save space. If the vibes feel off, the model isn’t broken, this just mean that your thread is just rotten.

Are you a “1 long thread” person like me or are you doing the smart thing and killing your sessions every hour to stay sharp?

What’s up, I’m Clint. Built software. Led teams. Now a founder helping builders who are ready to make the leap but can’t quite see the path yet. Every post is one conversation closer to clarity on ownership, execution and momentum.

The AI is moving fast.
If you having trouble managing your context window
& need better prompts , let’s do a:

Schedule Diagnostic Session

What Is The Real Problem?

The context window? The AI stack? Compute? All real, but for devs, it always comes back to one thing: Tokens.

When you run out of tokens on one tool and jump to another, you don’t just lose context you also lose momentum.

The new tool doesn’t know your architecture. It doesn’t know what you decided last week, in it’s compressed memory. It doesn’t know what you already tried and why you rejected it.

So it guesses. And you correct it—and that correction costs tokens.

Now you’re burning the new AI tool’s context memory fixing things the old tool already knew.

What’s up, I’m Clint. Built software. Led teams. Now a founder helping builders who are ready to make the leap but can’t quite see the path yet. Every post is one conversation closer to clarity on ownership, execution and momentum.

Subscribe now

The hidden tax of multi-tool development and the imperfect AI stack nobody is talking about. But why would they talk about it, when they’re supposedly getting more work done.

Productivity; that’s what every organization wants, and what devs are expected to produce more of.

So naturally, devs will push harder to produce more to get over the “problem.”

It’s in our DNA.

But there’s a deeper layer.

Try it, a quick search clearly shows that on average, it takes 23 minutes to fully rebuild focus after a single interruption and that’s on a normal dev day.

Headset on, deep in it, and your manager walks over to ask a “quick question.” Boom. Focus gone.

In an 8-hour day, the average developer gets only 2.3 hours of actual deep work. This is not a new stat, it’s been the norm.

So imagine now with AI tools multiplying the number of things you can have in motion at once. 🤯

AI doesn’t solve the context switching or interruption problem.

I kinda think it’s now going to be worse—amplified—for vibe coders and devs with big egos.

Do you still think tokens is the problem?

The Self-Imposed Switch

I’ll admit, the most expensive context switch used to be the email, Slack message, quick touch base, or the calendar reminder.

But now?

It’s going to be the one you choose.

You’re waiting for the AI to build something—the token worry begins. It’ll take 3 minutes. So you open another tab. Start another prompt in a different tool—no tokens here. Check a feed. Take a mental note about a feature you could add.

By the time the first build is done you’re already somewhere else mentally.

That literally happened to me recently, so I can only imagine how that plays out on today’s AI teams.

Your brain leaves traces on the last thing you were doing, a literal residue that doesn’t clear fully.

Stack enough of those and you hit decision fatigue—fast.

From the small decisions you keep making about where to put your attention next.

When I was in corp, I used tactics like the Eisenhower Matrix, SPACE Framework, and GTD—to prioritize where my attention and my team's went in real time.

Front-load the priority, then just execute.

But can these still work in today's overproductivity environment?

Look! It’s A Shiny Object

Scope creep is more real-er than ever before—because now every idea feels executable.

Shhh… you an probably get it done today.

You can spin up a prototype right now—so why not do it?

And then you or your boss have another one. And another. And suddenly you’re managing JIRA tickets with a bunch of half-finished projects instead of shipping one.

The rule is to keep even your MVP inside scope and don’t creep.

That has always been the rule, but you can’t stop your brain or your stakeholders from asking: “What if it could also do this?”

That question has killed more “in-progress” projects than bad engineering or a rouge AI implementation

If you’re on a team, that’s the manager’s job. But when you’re a solo builder like I am?

You have to manage yourself

It’s harder, but not impossible

That discipline will carry you through all the way to shipped.

Tokens! Do We Need A Reality Check

Here’s what you’re actually working with in 2026:

• A typical feature rich React component: ~2,500–3,500 tokens

• A 10,000-word documentation file: ~13,500 tokens

• Anthropic’s Claude Code | Sonnet 4.6 / Opus 4.6:
  1M token context window now is generally available at standard price with no long-context premium. Burns fast during active build sessions. Sonnet is my sweet spot, and when it can’t figure things out, Opus to the rescue, of course plan to rest after opus is done or stop you, lol.

• OpenAI’s Codex | GPT-5.4:
  Standard context window is 272K tokens, but Codex users can configure up to 1M tokens experimentally. In my experience burn rate seems slower, no sure why. Maybe the context compression on the Codex side is doing something smarter. I was curious do did more digging: anything over 272K tokens gets priced at 2x input and 1.5x output for the full session—do your own research anyway, these things changes fast.
  Local AI Master
  Qodo

• Antigravity | powered by Gemini with optional model switching (GPT, Claude):
  The real power here—and I’m now seeing Cursor can do this too—is the ability to test with screenshots and recordings autonomously. Burn rate still fast, then you fall back to Gemini Flash which is fast but lighter. On top of that, you can pair program with Gemini’s floating chat—in an earlier version I could share my screen so it could see the IDE directly, but I don’t see that option anymore.

This is just my feedback as a solo builder on base plans. Things are probably different if you’re on top tier or even better, your company is paying for it. And then who cares right? lol

Then it’s up to the company to decide: does burn rate == ROI?

Whether solo or business, the reality is the same; when you’re actively building, prompting, iterating, debugging, asking the AI to hold multiple files in mind, you will burn through a working session in under two hours without noticing.

And when context switching between tools is no longer necessary—due to token limits stop being a concern—thank the model optimization.

Burnout becomes your ultimate human problem.

If You MUST — Keeps Consistency Across Tools

Every project I work on now has the same set of “Skills” regardless of which tool I’m in. These are for continuity and not for context switching—I’ve learned my lesson, haha.

README.md: What this project is. Standard format.

ARCHITECTURE.md: How it’s built. The stack, the structure, the decisions and why. Load this first in every new session. It gives the AI the mental model it needs to not hallucinate your design.

ROADMAP.md: Where it’s going. Phases, not just features. What’s done, what’s in progress, what’s next. This is also your scope document — if a feature isn’t on the roadmap, it doesn’t exist yet and goes to the deferred section.

CHANGELOG.md: What changed and when. Human-readable version control. This is how you hand off context between tools without starting from scratch.

SANITY_CHECK.md: This one’s mine. It covers:

• The mindset we’re working with on this project

• Coding principles: TDD, unit tests, integration tests scoped to the feature

• The process: build → test → report → commit — in that order, every time

• A reminder of what this project is actually for

When I start a session in any tool I load these files first. That primes the context before a single line of code is written.

I’ve spoken to other builders who keep one massive document that does all of this, it works for them.

I find this structure easier to manage with multiple files, because after each session I ask the AI to update them.

No more guessing.

SANITY_CHECK.md

I’m sure I’ll add to this later:

# App Building & Sanity Rules

**Definition of ACTION:** Any task involving coding, developing, programming, UI/UX designing, database architecting, DevOps/infrastructure configuration, or security engineering.

---

## BEFORE ACTION
* **Mindset:** Apply KISS, SOLID, DRY, and YAGNI (You Ain't Gonna Need It).
* **Debugging:** Prioritize log analysis for clues before taking action or making assumptions.
* **Alignment:** Preview roadmap and perform architecture scan.
* **Research:** Conduct technical discovery and dependency audit (size, security, and maintenance).
* **Planning:** Break down the request into phases and get user approval before starting.
* **Architecture:** Update architecture and roadmap if the plan is approved.
* **Testing:** TDD (Test Driven Design and best practices should be implemented upfront with any pre written (backend and fronend test where applicable)

## DURING ACTION
* **Logging:** Implement CRUD logging (INFO/WARN/ERROR) for **both frontend and backend systems**.
* **Security:** Actively look for security gaps and fill them automatically during development.
* **Atomic Commits:** Never mix feature additions with refactors in a single commit.
* **Testing:** Create unit tests for any new or complex logic to be executed later and verify TDD cases to be added on the fly as we discover misses.
* **Config:** Identify and manage environment variables and secrets early in the phase.

## AFTER ACTION
* **Validation:** Run linting, unit tests, and E2E tests; ensure all pass.
* **Security Audit:** List any identified security gaps and the specific solutions implemented.
* **Documentation:** Update README, Architecture, and Roadmap to reflect current state.
* **Versioning:** Bump the semantic version in `package.json` based on the work implemented.
* **Reporting:** Show "Tests Passed" status, the last 7 commit hashes, and the current version and state if we're on track with TDD and if there's any new proposed TDD cases that should be added to next phase. 
* **Handover:** Provide a summary of changes and instructions for manual testing.

--
# Sanity Rules Deatailed
1. Development Protocol (the mental model)
   - KISS, SOLID, DRY, YAGNI — defined, not just named
   - TDD lifecycle: forethink → red → green → refactor → validate → insights
   - Atomic commits: one concern per commit, no mixing features + refactors
   - Prompt discipline: small, scoped, no hallucination surface area

2. TDD Workflow (the loop)
   - Round start: present forethought (what we learned + proposed test cases)
   - Approval gate before any code is written
   - Red/green/refactor is the coding loop
   - End of round: validate all cases pass, capture new cases discovered
   - Insights feed the next round's forethought

3. Event Logging Standard (non-negotiable)
   - Every system event gets a log entry + log level
   - Levels: DEBUG / INFO / WARN / ERROR — when to use each
   - Backend: structlog, frontend: loglevel → reports to backend
   - No silent failures — if it happened, it's logged

4. Security (non-negotiable, every phase)
   - API keys, MCP transport, OAuth tokens — how they're handled
   - Never committed, always in .env, always validated by pydantic-settings
   - Auth/authz comes later for UX — but security guardrails from day 1
   - MCP server security: transport layer, tool exposure rules
   - pip-audit in CI, private key pre-commit hook — always on
   - Security review is part of every after-action audit

5. After-Action Audit (end of every phase)
   - Did we follow KISS/SOLID/DRY/YAGNI?
   - Are all events logged with correct levels?
   - Did any new security surface area open up?
   - Are all tests passing including new cases found during dev?
   - Is CI green?
   - Did we bump the version in package.json?
   - Update CHANGELOG, ARCHITECTURE, ROADMAP to reflect reality
   - Capture insights → seed next round's forethought

6. Continuous Value Check (during every round)
   - Before adding anything: does this serve the current phase goal?
   - YAGNI gate: if it's not needed now, it goes to ROADMAP not code
   - Small phases, ship something real, check value, iterate

My Execution Points - For Focus

Claude (for everything) — Primary. Daily work, practical features, anything connected to real-world business logic. Chat and Co-work—cause why not, this thing is powerful! Then Opus for heavy lifts on complex problems. I stay here as long as I can.

Codex — Overflow. When Claude tokens run low I bring a project folder into Codex. Feed it the documents and it picks up cleanly.

Antigravity — Small projects and scaffolding to get things started. Kinda buggy for me, but still exploring.

Cursor — Still learning. I see power here but this one is for when you MUST have eyes on the code.

The rule: one primary track per session.

I don’t jump tools mid-thought—anymore.

I finish the unit of work, commit or checkpoint, then move if I need to.

Your job becomes: direct, review, approve, adjust. Not write.

That sounds like less cognitive load, but In practice it can be more—because now you have to hold the intent of the system in your head while the agent executes.

If you don’t have your docs locked down, the agent makes decisions you didn’t authorize based on assumptions and sometimes that’s fine, but it can also be costly.

The document system matters even more in agentic and complex workflows. When you first start, probably none of this matters but later, when you begin tweaking features and fixing bugs, it’s a godsend.

Since moving between these tools is a thing for me, I needed to keep them in sync, as a result, I created a tiny project.

Not because I needed another project to break my focus, or rebuild what already exists.

I just needed to get something done—you know, motivation.

So I built a small open source GitHub project to sync my Skills files across tools and project roots.

The goal is to use an AI agent to execute.

The Bigger Picture — This Is a Focus Problem

80–90% of personal dev projects never get finished.

The why is that capable builders spread themselves across too many mental tracks and run out of the one resource that actually matters:

Focused Energy!

The habit to build in this new era isn’t learning the best tool.

It’s protecting the single track.

And here’s the thing about builder’s shame: doing too much with no result still brings shame.

The idea you circled back to for the eighth time but never shipped feels bad.

The answer isn’t to stop having ideas

It’s to build the one you’re on until it’s done, and let the rest wait.

Learn just enough to start

Keep going

Evolve from there

What’s up, I’m Clint. Built software. Led teams. Now a founder helping builders who are ready to make the leap but can’t quite see the path yet. Every post is one conversation closer to clarity on ownership, execution and momentum.

I just showed you the complexity.
If you want me to look at your specific architecture,
book a teardown session.

Ready?

Research Notes

Context Switching / Side Projects, Never Finish / Toxic Productivity / Mental Health

1. The Hidden Cost of Context Switching: Why Your Most Productive Hours Are Disappearing
   https://medium.com/@codewithmunyao/the-hidden-cost-of-context-switching-why-your-most-productive-hours-are-disappearing-43c5b501de19

2. Context Switching: The Silent Killer of Developer Productivity https://www.hatica.io/blog/context-switching-killing-developer-productivity/

3. Cost of Context Switching for Developer Workflow https://axolo.co/blog/p/cost-context-switching-developer-workflow

4. How Much Does Context Switching Cost Your Dev Team https://www.incredibuild.com/blog/how-much-does-context-switching-cost-your-dev-team

5. Context-Switching Is the Main Productivity Killer for Developers
   https://newsletter.techworld-with-milan.com/p/context-switching-is-the-main-productivity

6. Context Switching Costs for Developers
   https://super-productivity.com/blog/context-switching-costs-for-developers/

7. Side Projects and Why They Never Get Finished https://dev.to/zybersudo/side-projects-and-why-they-never-get-finished-2fk6

8. Why Developers Never Finish Their Projects
   https://medium.com/things-developers-care-about/why-developers-never-finish-their-projects-bf39d3424114

9. 5 Reasons Why Side Projects Never Get Finished
   https://web-highlights.com/blog/5-reasons-why-side-projects-never-get-finished/

10. The Hidden Cost of Always Being Productive https://www.psychologytoday.com/us/blog/unlock-your-true-motivation/202506/the-hidden-cost-of-always-being-productive

11. When Productivity Turns Toxic https://www.forbes.com/councils/forbesbusinesscouncil/2024/07/10/when-productivity-turns-toxic-how-to-avoid-excessive-output-at-work/

Share

Subscribe now