I was working with AI on a system that could answer a deceptively simple question:

What actually needs my attention right now?

Not just whether a server responds to a ping. I mean all of it: outages, security alerts, backups, client requests, calendar deadlines, half-finished projects, unpaid work, messages I still owe someone, things somebody else promised me, and the task I was definitely going to remember without writing down.

The usual software-industry response would be to name this something like:

Unified Operational Intelligence and Remediation Coordination Platform

Then shorten it to UOIRCP, schedule six meetings about its dashboard, and forget why we built it.

Instead, I typed:

check my shit

The AI did not object. It did not suggest a more professional brand. It did not ask whether I meant “digital assets” or “operational resources.”

It effectively said: Good. That is the trigger, because it is what you will actually say.

That was the moment I lost it.

The joke is that it took the name seriously

Later, I showed the exchange to ChatGPT and asked why it was so funny.

Its answer was dead-on: the AI treated check-my-shit like a perfectly respectable Unix command that had escaped from a sarcastic engineering team. Then it built real architecture around it.

quick check my shit

Tell me if anything is on fire.

check my shit

Give me the normal work-and-life command ledger.

complete check my shit

Inventory everything. Reconcile every device, IP, domain, backup, project, promise, and open loop. Abandon hope, but bring evidence.

You can narrow it without inventing another tool:

check my shit, security only
check what I promised
check home shit
check everything, but do not change anything

The words after the command change the depth or scope. They do not create a competing queue.

That is legitimate software design attached to a command named check-my-shit, which is objectively funny.

What “my shit” actually means

The problem was never a shortage of dashboards.

There is a dashboard for monitoring, a dashboard for backups, another for endpoint security, another for tasks, another for billing, two inboxes, calendars, text messages, chat archives, project notes, bots, server consoles, camera systems, and several places where Future Me left Current Me a surprise.

Each system can be telling the truth while the overall picture is still wrong.

A backup dashboard can say success even though nobody has tested a restore. A task can say done while the client is still waiting to accept it. A service can be installed without being configured, reachable, healthy, useful, or trusted. An inbox can be quiet because the important message landed in the other inbox.

So check-my-shit is not another status page. It is a closure engine.

It collects current evidence from the places where reality lives, reconciles duplicates and contradictions, and turns the result into one ranked ledger:

1. Do now
2. Today
3. This week
4. Waiting
5. Decide
6. Closed since the last check
7. Coverage gaps

Every open item needs an owner, a next physical action, a due date or gate, an evidence time, source pointers, and a confidence level.

“Justin promised,” “somebody else promised,” and “the model inferred this might matter” are three different things. The tool is required to keep them different.

Three depths, not three new systems

The installed version has three modes:

Quick mode is smaller, but it is not sloppier. It still has to account for every source its contract requires.

Complete mode is deliberately painful about inventory. If there are a few hundred registered endpoints, it does not get to inspect 20 and write “and the rest looked fine.” The numbers have to reconcile:

expected = checked + unavailable + failed + not_applicable

That equation is boring.

It is also the difference between an audit and a vibe.

The non-sysadmin translation

You do not need to know what a source lane, coverage receipt, or canonical action queue is to understand the idea.

Imagine asking one competent person to walk through your house and business before you leave town:

• Is anything actively leaking, smoking, blinking red, or making a noise it should not make?
• Did the important deliveries arrive?
• Did somebody leave a message that needs an answer?
• Are the doors locked and the cameras working?
• Did the bills get handled?
• Is there something on tomorrow’s calendar that requires preparation today?
• Did you promise to call somebody back?
• Is the person you are waiting on finally done?

Now imagine that person is required to carry a checklist. If a locked room cannot be inspected, they have to write ROOM NOT CHECKED instead of assuming it is fine.

That is check-my-shit.

The servers, APIs, task queues, and message archives are implementation details. The human result should still be simple:

Here is what matters. Here is what can wait. Here is what changed. Here is what I could not verify. Here is the next thing to do.

If the output needs a certification course to understand, the command has failed—no matter how impressive the collection machinery was.

The most important result might be “I could not check”

AI assistants are very good at producing confident summaries. That is useful right up until a disconnected source silently disappears from the summary.

If personal email was unavailable, the tool cannot claim there were no urgent messages.

If the backup service could not be reached, it cannot claim backups are healthy.

If it can see incoming text notifications but not sent replies, it cannot claim the conversation was fully checked.

check-my-shit makes access failure part of the result. Every expected source must end in one explicit state:

• checked
• partial
• unavailable
• not configured
• not applicable
• failed

Silence is not a pass.

The validator rejects missing sources, unreconciled inventories, and a falsely “complete” run that still has failed coverage.

This is less exciting than an animated green dashboard.

It is much more useful at 2:00 a.m.

A check is not permission to touch anything

Another rule: the command defaults to read-only.

Asking what is broken does not authorize the AI to send email, close tasks, pay invoices, restart servers, deploy code, delete files, contact clients, or “fix” production.

Those are separate decisions.

The check can gather evidence, prepare reports, and tell me the exact next action. It cannot quietly turn an investigation into an incident.

This matters because the most dangerous automation is not the one that crashes loudly. It is the one that confidently does the wrong helpful thing.

It refuses to make another inbox

I already have enough places where obligations can hide.

The tool treats the task system as the canonical action queue. Email, calendar, chat, texts, monitoring, notes, bots, and billing systems are evidence and intake surfaces.

Before proposing a new task, it has to ask whether the obligation already exists. It matches by system, client, owner, due date, and evidence. Contradictions stay visible instead of being “cleaned up” into whichever answer is convenient.

The goal is not to generate a magnificent new backlog.

The goal is to close things.

Yes, I actually built it

This stopped being a joke on July 29, 2026.

The installed skill now has:

• 10 required source lanes in quick mode
• 17 in normal mode
• 25 in complete mode
• five tested behavior cases covering the main modes and scoped checks
• a machine-readable coverage receipt
• negative tests that prove it rejects missing coverage and false completion
• complete Markdown and dark, phone-friendly HTML output for every run

It is not omniscient. It can only check sources that are connected and working. The difference is that it has to tell me exactly what it could not see.

That is a feature, not an apology.

Peak sysadmin energy

In my head, the ideal run still looks like this:

$ check-my-shit

✓ Servers responding
✓ Cameras recording
✓ Backups current
✓ Security alerts reconciled
✓ Client promises accounted for
✓ Forgotten work dragged into daylight

! Steve unplugged something again

Coverage: 17/17 sources accounted for
Next action: plug Steve's thing back in

Steve is fictional.

Probably.

The best interface is the one I will use

There is a serious reason the name survived.

“Run the unified operational reconciliation workflow” is technically respectable and mentally expensive.

“Check my shit” is three syllables, zero ambiguity, and exactly what my brain is trying to ask.

For an overloaded operator—or anyone whose attention does not arrive in neat enterprise-approved rows—the friction between remembering a command and not remembering it is the entire product.

Good UX is not always elegant.

Sometimes it is blunt, memorable, slightly unprofessional, and honest about what the software does.

The joke is that check-my-shit sounds ridiculous.

The better joke is that it may be the most accurately named tool I use.