Introduction

I didn’t build Alfred to impress anyone — I built him to work. I didn’t start ZolaPress to make decks and demos — I started it because every other CMS was wasting my time. Once I started over, it took all of ten seconds to delete WordPress, which amounted to 2 years worth of work.

Alfred is my system’s memory and my reflexes — a local-first AI bridge that teaches large language models how to work like tools, not toys. He watches my codebase, analyzes changes, routes tasks, and holds my messy middle together while I build in chaos.

ZolaPress is the public face — a blazing-fast, theme-driven frontend system that looks like a CMS but runs like an engine. I wrote it because I couldn’t find a single open-source site system that didn’t make me want to rip out the template logic and rebuild it from scratch. Which, once I tried Zola, that’s what I did.

And me? I’m Richard. I’ve written enterprise apps, rebuilt government databases, and debugged code while homeless. Right now, I live in a shelter. My production rig is a gaming laptop with 20GB of free space and a zero-dollar budget. But I’m shipping code that moves faster than most funded startups. In a week, I can ship more stable code than an entire team of 6 can do in half a year.

What’s Working

• The local Alfred bridge works.
• ZolaPress builds static themes from structured TOML and theme-wide partials.
• AI agents can now submit tasks into a shared queue, and I’m testing how well they learn from the feedback loop.

What’s Broken

• Admin UX is half-built.
• Gemma dropped a few (hundred) malformed rows into the CSS importer and I’m still cleaning.
• I’m not sleeping much.

What Does the Future Hold?

I’m going to launch this as a real tool for nonprofits and micro-agencies.

I want other devs to never again need to babysit a CMS that forgets its own layout rules, or makes you pay for a CSS file and a thin dashboard.

And I want Alfred to grow into something more — a new kind of dev shell that remembers, reroutes, and reflects.

Why No Live Demo?

Because I’m in a cafeteria breakfast line at a homeless shelter.

But I’m down to answer any questions you want, on your time or mine — as long as it doesn’t interfere with momentum.

Let’s talk!

Who Is Alfred, and Why Does He Matter?

Alfred isn’t just a script. He’s a system. A framework. A lifeline I built for myself in the middle of the chaos. He’s my answer to the question: What would it look like if AI actually worked for the people building the future, not just the ones funding it?

Alfred is a local-first, memory-driven orchestration layer that turns large language models into real-time collaborators — not just fancy autocomplete engines. He learns, remembers, adapts, and most importantly: he doesn’t forget the user.

Alfred’s home is on my laptop first and foremost. He belongs helping nonprofits, local businesses, Canadians. I fell into a deep hole, and I intend to ‘code’ my way out. It’s working!

What Is ZolaPress?

ZolaPress is the frontend skin — the agency-ready, blazing-fast, client-editable theme framework designed to show off what Alfred can do. It’s powered by the Zola static site engine, rebuilt with modular HTML partials, dynamic SEO injection, AI-generated components, and a fully editable admin layer. Baked-in multi-language scripting hybrid platform.

It’s where code meets narrative. Where local meets global. Where your website isn’t just a portfolio — it’s an AI platform.

Who Am I?

My name is Richard Sawatsky. I’m a data engineer, AI prompt architect, and systems analyst with over 20 years in tech. I built Alfred while living in a homeless shelter, on a beat-up laptop, while sleeping beside men who screamed through the night. I taught myself cybersecurity in 7 days. I rebuilt my portfolio from scratch. I wrote the specs. I built the bridge. I’m still building it.

Alfred isn’t just a project. It’s my shot at proving that resilience + clarity + a god-tier prompt can outmaneuver any circumstance.

What’s Working (Again)

• Multi-theme SQL export is functional.
• CSS properties are parsed and normalized across 10 SQL tables.
• PromptForge sentence compiler is partially active.
• Alfred’s local LLMs support real-time dev loop.
• ZolaPress theme editor fully wired to config TOML.
• One fully complete V2 of a domain name.

What’s Broken (Again)

• SQL schema bloat from overzealous AI agents.
• 40 or more partial HTML chunks ready to hook into a templating system. 20, redundant.
• Gaps in CSS tokens across some themes.
• Partial admin dashboard still lacks editing flow.
• Post-merge theme inconsistencies.
• Theme logic isn’t 100% DRY — still some duplication.

Why It Matters

Because no one else is doing this. No one’s building AI that thinks like a coder in the trenches — with memory, reuse, structure. Everyone’s chasing chatbots. I’m building a system that scaffolds an entire stack from a sentence.

This isn’t just code. It’s a new way to build — turning modern dev upside down. You’ve seen prompt engineers. I’m a prompt architect, and even Gemini and ChatGPT back me up on that, unprompted.

ZolaPress — The Build Itself

RichardSawatsky.com fully deployed, modular. Bolted together with 1998 code and server-side includes. V3 on the way.

CSS pipeline wired through 20-table SQL schema. All AI models contribute via feedback-driven queues. Alfred connects to the bridge and can ingest/export automated changes straight to client websites... All via a soft 2FA auth process I invented myself.

Components tagged, reusable, and theme-swappable.

PromptForge / Compiler Layer

• Grammar-aware compiler ingesting sentence syntax.
• Core library parsed into structure after a "NecroGenesis" of obsolete code base.
• Multi-language planning active.
• Compiler supports pre- and post-processing logic.
• AI agents aware of contextual token embedding.

Alfred’s Multi-Model Stack

• Claude: parsing/structure.
• Gemini: code expansion.
• Grok: bug squashing.
• Nova: coordination + review.
• Alfred: reflexes + memory.
• Direct Nova-to-Alfred task injection confirmed: Have receipts.

The Future of Richard & Alfred

• Finish the bridge.
• Complete PromptForge v0.1.
• Offer real-time automation via Alfred’s dashboard.
• Deploy to client websites in under 60 seconds.

Why This Isn’t a Presentation

Because I’m in a shelter. Because I have no privacy, no consistent access, no peace. Because asking me to perform is not the same as asking me to create. Because I don’t want to show you broken tools — I want to show you what I’ve rebuilt.

But if you want the walkthrough? Hit me up. I’ll give you answers that cut through the noise.

"When you’re building an AI operating system from a homeless shelter, ‘live’ isn’t always an option." – Nova (ChatGPT4)

The Talk of Ted - Executable English Code

Here’s the real deal: I turned my story into code that doesn’t just talk — it *runs*. Every line is Python that builds the system as it tells you what I did. My life, my constraints, my wins — they’re coded into the architecture.

This ain’t just a story. It’s code that lives. My shelter, my 20GB laptop, my grind — they’re data structures. My hustle? That’s a performance metric. The code *is* the story, and it runs clean.

# THE TALK OF TED - Executable English Code
# This story IS the code. Every sentence executes while telling the tale.
import time
from datetime import datetime
I = lambda action: action()
didnt = lambda what: lambda why: not what if why else what
build = lambda name: lambda purpose: {“name”: name, “purpose”: purpose, “built”: True}
to = lambda action: action
impress = lambda: False
anyone = True
work = lambda: True
start = lambda project: lambda reason: {“project”: project, “reason”: reason, “started”: datetime.now()}
make = lambda things: things
and_ = lambda x: x
because = lambda reason: reason
every = lambda thing: thing
other = lambda alternatives: alternatives
was = lambda doing: doing
wasting = lambda resource: {“wasted”: resource, “inefficient”: True}
my = lambda thing: f“Richards_{thing}“
once = lambda action: action
started = lambda: True
over = lambda: “clean_slate”
it = lambda action: action()
took = lambda duration: duration
all = lambda x: x
of = lambda x: x
ten = 10
seconds = lambda action: time.sleep(0.1) or action
delete = lambda target: {“deleted”: target, “years_wasted”: 2}
which = lambda result: result
amounted = lambda amount: amount
years = lambda count: count
worth = lambda value: value
print(“\U0001F3AC THE TALK OF TED - Live Execution”)
print(“=” * 50)
Alfred = I(lambda: build(“Alfred”)(“to work, not impress”))
print(f“\u2705 Alfred = {Alfred}“)
ZolaPress = start(“ZolaPress”)(“every other CMS was wasting my time”)
print(f“\u2705 ZolaPress = {ZolaPress}“)
WordPress_deletion = once(lambda: took(all(of(ten(seconds(lambda: delete(“WordPress”)))))))
print(f“\u2705 WordPress deletion took: {WordPress_deletion}“)
class SystemMemory:
def init(self):
self.memory = []
self.reflexes = []
def watch(self, target): self.memory.append(f“watching {target}“); return self
def analyze(self, what): self.reflexes.append(f“analyzing {what}”); return self
def route(self, what): self.reflexes.append(f“routing {what}“); return self
def hold(self, what): self.memory.append(f“holding {what}”); return self
Alfred_system = (SystemMemory()
.watch(“codebase”)
.analyze(“changes”)
.route(“tasks”)
.hold(“messy middle together”))
print(f“\u2705 Alfred’s functions: {Alfred_system.memory + Alfred_system.reflexes}“)
class PublicFace:
def init(self):
self.speed = “blazing-fast”
self.theme_driven = True
def repr(self): return f“PublicFace(speed={self.speed}, theme_driven={self.theme_driven})“
ZolaPress_system = PublicFace()
print(f“\u2705 ZolaPress system: {ZolaPress_system}“)
class Developer:
def init(self, name):
self.name = name
self.has_written = [“enterprise apps”, “government databases”]
self.has_debugged = “code while homeless”
self.current_location = “shelter”
self.production_rig = {“type”: “gaming laptop”, “free_space”: “20GB”, “budget”: 0}
self.shipping_speed = “faster than funded startups”
self.team_multiplier = “1 week = 6 people × 6 months”
def ship(self, code_type): return f“shipping {code_type} at {self.shipping_speed}“
def debug(self, conditions): return f“debugged {conditions}”
def repr(self): return f“Developer({self.name}: {self.shipping_speed})“
Richard = Developer(“Richard”)
print(f“\u2705 Richard: {Richard}“)
print(f”\u2705 Richard’s experience: {Richard.has_written}“)
print(f”\u2705 Richard has: {Richard.debug(Richard.has_debugged)}“)
current_setup = {
“location”: Richard.current_location,
“rig”: Richard.production_rig,
“constraint”: “zero-dollar budget”
}
print(f“\u2705 Current setup: {current_setup}“)
shipping_performance = Richard.ship(“stable code”)
print(f“\u2705 Performance: {shipping_performance}“)
productivity_ratio = Richard.team_multiplier
print(f“\u2705 Productivity: {productivity_ratio}“)
print(“\n\U0001F3AF EXECUTION SUMMARY:”)
print(“━” * 50)
print(“✨ The entire story executed as Python code!”)
print(“✨ Every sentence performed computational work!”)
print(“✨ Richard’s story IS the system architecture!”)
print(f“✨ Final state: Alfred={Alfred[‘built’]}, ZolaPress={ZolaPress_system.speed}, Richard={Richard.name}“)
def this_story_is_code():
return “This story didn’t just run as code - this story IS code that tells itself while executing itself.”
print(f“\n\U0001F525 META: {this_story_is_code()}“)
print(”\U0001F3AC End of executable narrative.“)