Problem-solver · Builder · Automation enthusiast

I solve problems.
Then I automate the solution.

I'm Cory. I build useful things and automate the boring parts. What I've really figured out is how much one person can build with AI when you actually know how to use it. Here's how I work, and what I've made.

Cory and the robot at the workbench, city at dusk
spark://home-platform ● systems online
34
services
20
containers
25
automations
0
inbound ports
1
operator
uptime: continuous run cost: ~$0/mo (free-tier + local models) stack: self-hosted built by: one person, directing AI agents
How I actually work

It's less "using AI" and more conducting.

The real edge isn't a tool. I run several AIs at once — one building, one writing, one drawing — and I'm the only thread between them. I don't write specs. I think out loud, react, redirect, and keep every stream moving so I'm never blocked. Whatever this site is, it's the output of that.

I honestly can't fully explain how I do it — so I asked Claude, the AI that built this site, to write it up. It put it better than I could:

"He isn't prompting. He's steering — loosely, continuously, by instinct — correcting course faster than the work can drift. It isn't a process he runs. It's a way of paying attention."
Read Claude's guest piece on how I work →
How I think

Find the real problem. Build the useful thing. Automate the boring part.

Everything I build comes back to the same few things. It's not a framework. It's just how I work.

01

Solve real problems

Not demos or résumé filler. The thing that's actually costing someone time or money.

02

Build useful things

If nobody's going to use it, I don't build it. Useful beats clever.

03

Automate the boring stuff

The best thing I build is the thing nobody has to do by hand again.

04

Keep learning

The tools change every few months. Stand still and you fall behind. That simple.

05

Stay curious

Most good things start with “huh, that's weird.” I chase it instead of ignoring it.

06

Help people

The whole point. If it doesn't make someone's day easier, it wasn't worth building.

The work

Things I've built and actually run. All solo.

A slice of it. Some is client work — real systems that businesses run on, and that I'm the one responsible for. Some I built on my own to chase an idea down. Names are redacted where they had to be. The numbers are real.

A projects control-center dashboard — system health, infrastructure, deploys, roadmap — with Cory at the whiteboard
↑ Roughly how I keep an eye on the things I run.
security · multi-tenant · built for an MSP

Multi-tenant firewall monitoring

The cross-client security dashboard the vendor never built — ~33,000 lines watching 100+ firewalls across 50-some client networks, with config-drift diffing, exfil scoring, auto-ticketing on circuit drops, and an alert floor tuned so it doesn't cry wolf.

Why it matters: one screen that answers "which client is on fire right now?"
disaster recovery · built for an MSP

Rebuild a whole fleet from one file

Bare Windows Server to a fully-restored fleet — every service, task, secret, symlink, and tunnel — in 15–30 minutes, from one executable and a passphrase. It self-updates from live state, so it can't rot the way a runbook does.

Why it matters: a DR story you can actually test, not one in a binder.
operations · noise · built for an MSP

A dozen consoles, one place to look

Endpoint, backup, network, identity, email security — a dozen vendor portals pulled into one digest that only speaks up when something's genuinely new. Acknowledge a finding once and it goes quiet across every source.

Why it matters: kill the daily-email graveyard nobody reads.
procurement · margin

The Distributor Desk

Live wholesale cost and stock from a national IT distributor's API, scored for real resale margin after fees — honest enough to say "I don't know the sell price" instead of faking a number.

Why it matters: know the real margin before you buy, not after.
commerce · self-maintaining

A storefront that rebuilds itself every night

A dealer catalog that re-derives itself from live supplier feeds — cost, stock, availability, MAP-floored pricing — and writes down everything that moved since yesterday. Nobody hand-keys a price. A claims linter fails the build on anything the data can't actually support.

Why it matters: the catalog can't drift from reality, because reality is where it comes from.
automation · bounded autonomy

Systems that heal themselves overnight

My platform diagnoses and repairs itself every night — an AI proposes, a hard-coded guardrail executes, with real restart authority and an out-of-band kill-switch.

Why it matters: the safe pattern for letting AI touch production.
velocity · solo

One person, a team's output

Agent swarms hitting one task at once, and a self-hosted platform of 30+ services and AI agents behind zero open ports, on ~$0/mo — built and operated by one person.

Why it matters: this is what I'd point at your backlog.
Read the full body of work → the whole thing · 22 projects, home + work
The range

The same approach, pointed at anything.

Directing AI well isn't a coding trick — it's a general-purpose skill. Same instinct, whether it's a real-estate appraisal, a car deal, a legal notice, or a piece of infrastructure. A few real ones, names kept out of it.

documents · negotiation

Turned a paper trail into leverage

Cross-referenced an appraisal against the seller's own contractor invoice on a home purchase — and found the listing's written "no moisture damage" claim contradicted by a signed bill for rot repair. The documents became the negotiating position.

negotiation · strategy

A car deal, fully war-gamed

Built an end-to-end buying strategy for a friend — same-lot comps as leverage, stripping the dealer-pack padding, out-the-door-only framing, a finance-then-refinance play. A plan, not a scoreboard: the deal was still in motion.

legal drafting

A notice with actual teeth

Drafted a formal notice of default against a property manager — citing the specific federal statute, state quiet-enjoyment law, and the exact lease paragraphs — with a parallel postal-inspection complaint alongside it.

product · invention

From a half-joke to a real device

Took "a vape for singers" and worked it down through the actual physiology and the battery physics to a workable architecture — then set a hard go/no-go gate before spending a dollar on a prototype.

product · forensics

A photo-authenticity product

Grew a dating-photo filter detector into a general image-forensics idea — pivoting to pixel-level detection after finding that listing sites strip EXIF, and mapping consumer-freemium against B2B-API paths.

AI infrastructure · running

A three-tier LLM router

On this box: a small classifier scores every prompt and routes it to a local model or the Claude API — cheap where that's fine, capable where it actually matters.

security tooling · internal

A watchdog on the audit log

An internal monitor for a practice-management platform — flagging bulk credential access, off-hours activity, and new-IP logins, with alerting. Built as internal tooling; it has a commercial shape.

verification · rigor

Fact-checked a viral fake

Ran a viral AI-generated photo all the way down — watermark detection, SynthID, timeline analysis — instead of guessing whether it was real.

How I work

How I work a problem.

It's a loop, not a project. The goal is fewer fires next quarter than this one.

Incident war-room: Cory at the system dependency map tracing a root cause while Claude works the runbook
↑ A real one — connection leak in OrderRepository. Identify, contain, fix, automate, move on.
01

Alert

Something's broken, or about to be. I start where the pain actually is, not where the fix is easy.

02

Investigate

Find the root cause. And distrust the first answer, especially a confident one.

03

Solve

Fix the actual thing. No band-aids that turn into next quarter's outage.

04

Automate

Then make sure it never needs a person again. This is the step everyone skips.

05

Monitor

Watch it in production, with guardrails, so the automation can't quietly do damage.

06

Repeat

On to the next one. Fewer fires over time is the whole point.

Who I am
Cory Dickes
Charlotte-based · always taking things apart to see how they work

By day I work in IT — and I have for about twenty years. I started out fixing and installing hardware, spent a long stretch deep in healthcare IT, moved into enterprise cloud, and I'm now on the security side at an MSP. Real systems, real stakes, the kind of place where a bad call has consequences. That's where I learned most of this.

A lot of that work has been premium, high-stakes support — VIP end-users who genuinely can't be down. Executives, clinicians, people mid-crisis who don't want a ticket number, they want it fixed. You learn fast how to stay calm, find the actual root cause, and solve it without the drama. That's the same instinct that shows up in everything else I build.

Nights and weekends I run a self-hosted platform — thirty-some services and a bunch of AI agents that watch it, fix it, and help me build the next thing. One person, all of it. I build something almost every day. It's the most fun I've had in years.

Same thing I did as a kid taking stuff apart on the kitchen table: figure out how it works, then make it work better. The rest is details.

Cory relaxing with a coffee while Claude organizes the story — core beliefs, lessons, life events
↑ What actually drives me: core beliefs, lessons, and a mug that's right.
The journey so far

Twenty-odd years of taking things apart and putting them back together better.

Curious kid, first lines of code, then IT, then automating everything I could. Keep learning, keep building, keep shipping. The short version's on the wall.

A wall timeline of Cory's career — early curiosity, first code, first IT role, automation, leadership, and what's next
↑ Start → 2006 first code → 2024 and counting. Certs, tools, and what's next, all on the board.
Writing

I write some of this down.

Notes on automation, building with AI, and turning messy problems into simple systems. Plain and practical, same as everything else here.

Claude drafting an article while Cory works the whiteboard: turn complexity into clarity
↑ The first one's up. More on the way.
Speaking

I like talking about this stuff.

Peer groups, conferences, whatever room will have me. No hype, no fear-mongering. Just what's actually working, including the parts nobody puts on a slide.

01

AI is a tool for engineers, not a replacement

What I actually believe: AI makes a good builder faster. It doesn't replace one. The judgment stays human.

02

Letting AI touch production without losing sleep

Bounded autonomy: how to give an AI real authority over systems while keeping the blast radius something you can read in one file.

03

Doing more with one

Agent swarms and AI-directed development for small teams — how one person ships like ten.

04

Real automation on a budget of basically zero

What one person can build on free-tier and local models. No enterprise invoice.

About this page

Straight up: I didn't code this by hand.

It's past midnight and I'm in bed with an iPad. That robot up there is Claude, and Claude's doing the actual typing. I say what I want, tell it what's wrong, make the calls on tone and what's honest. It writes the code, builds the sections, and tells me when I'm being dumb.

That's kind of the point. This page doesn't just describe how I work with AI. It is how I work with AI. One tired guy, one fast robot, a few late nights, built section by section. The judgment's mine. The typing speed isn't.

I'm not shy about it, because it's the thing I actually believe. Someone who knows what they want, pointed at a tool this good, is a different kind of builder than they were two years ago. This site's just the smallest proof I can point at.

~2½ hrs
Every line of code, all the writing, and 29 illustrations, each one drawn, cropped, and placed — this site plus the cartoon-universe case study — came together in one sitting. Not because any single AI was fast, but because I ran three at once: one drawing (Copilot), one writing (Claude), one building (Claude). This page included.

The full making-of → how all this came together in 2h 35m

One thing you can't catch in a screenshot: this site tells its story a little differently every visit — same facts, same voice, just a different telling. Early-morning quiet, loose like it's late at a bar, or straight to the point — like the same set played on a different night. Every version is written by hand, so it never drifts. What you just read was one performance of it.

Honestly, that button is the tell. Nobody sits down and writes the same page four different ways by hand — the fact that it can retell itself on command is the proof a person didn't write this. That's the whole idea.

Claude the robot building this website at the workbench while Cory looks out over the city at dusk
↑ Claude doing the actual building — that's this site's checklist on the screens. I'm the one with the crossed arms, being picky.
Say hello

Got something interesting? Let's talk.

A question, an idea, something you're stuck on, or you just want to talk about building with AI. All good. I also do consulting, workshops, and talks when it's a fit.

Cory waving hello; Claude at the communications console routing incoming messages
↑ Yes, Claude triages the inbox. No, it doesn't reply for me — every message is a person.

Or just send a note

Speaking, collaborating, or something else. This reaches me.

Same story, every time — told a different way. Give it a click.