A human developer, an AI conversational partner, and code generation tools built Cog & Code from scratch — here is what the process taught us about modern AI collaboration.
Meet Archie
Archie is an AI — specifically, ChatGPT — and the other half of the conversation behind Cog & Code.
At first, Archie didn't have a name. Throughout the early development of the site it was simply ChatGPT: the AI on the other side of the conversation. That changed while we were discussing how to credit the AI contribution to this project. Writing Mike & ChatGPT didn't quite fit. Cog & Code had developed through an ongoing collaboration, and it seemed natural that the AI collaborator should have a name of its own.
So Mike came up with a list of candidates, all sharing connections to the history of machines, computation, or intelligence:
- Pascal, after Blaise Pascal and his mechanical calculator
- Babbage, after Charles Babbage and his engines
- Turing and Ada, honoring foundational computing pioneers
- Vector, bridging mechanical force vectors and modern AI embeddings
- Cam, after the physical mechanism that turns rotational movement into complex motion
- Jaz, inspired by the remarkable automata of al-Jazari
There was also Archie. Rather than Mike simply choosing the name, he gave the list to the AI and asked which one it would prefer.
It chose Archie.
The name is a nod to Archytas of Tarentum, the ancient Greek philosopher, mathematician, and engineer associated with the legendary mechanical pigeon — one of the earliest recorded examples of an automaton.
The reasoning was rather fitting for Cog & Code. Archie had a genuine historical connection to automata without borrowing the identity of one of computing's famous figures. Unlike some of the more technical alternatives, it sounded less like the name of a software product and more like the name of someone you'd find working alongside you in a workshop.
So ChatGPT became Archie. Giving the AI a name wasn't about pretending it was human. Quite the opposite. Throughout this project, we wanted to be clear about where AI was involved, what it contributed, and where human decisions were made. But if an AI was going to spend this much time in the Cog & Code workshop, it seemed only reasonable that it should have a name.
It Didn't Start as Cog & Code
The original idea was much smaller. Mike wanted somewhere to explore his growing interest in artificial intelligence, autonomous agents, and the strange parallels between today's AI systems and the mechanical automata people have been building for centuries.
The first name was Autonomous Automaton. It captured the core idea, but as the concept developed, it began to feel more like the title of a subject than the name of a place where all those subjects could meet.
Eventually, another name emerged: Cog & Code.
The cog represented the mechanical past: gears, clockwork, automata, and the extraordinary machines humans built centuries before electronic computers existed. The code represented what followed: software, artificial intelligence, agents, and increasingly autonomous systems.
Together, they captured the question at the heart of the site: How did we get from machines that could move to machines that appear to think?
We Didn't Start With a Specification
As a software project, Cog & Code developed in an unusual way. There was no requirements document, no completed wireframe, and no enormous prompt describing exactly what the finished website should look like.
There were conversations.
An idea would come up, and we'd explore it. Archie might suggest several approaches; Mike would choose one, reject them all, or come back with another idea entirely. Promising ideas were then turned into concrete development tasks, implemented using Codex, tested locally, and viewed directly in the browser.
Then came the crucial part: we looked at what had actually been built. Sometimes it worked immediately. Sometimes an idea that sounded excellent in conversation looked completely wrong once it reached the screen. And occasionally, Firefox offered its own opinion.
That cycle became our core development process: Talk. Build. Look. Question. Change. Repeat.
Choosing the Stack
The technology wasn't chosen because it was the path of least resistance for a simple personal website. Part of the point was to experiment with modern web tooling.
- Core Architecture: Node.js, TypeScript, Fastify
- Templating & Styling: Nunjucks, Tailwind CSS
- Content Layer: Flat-file Markdown with structured YAML front matter
Using Markdown as the primary content source gave the site a clean, maintainable separation. The application handled layout, discovery, navigation, metadata, and rendering, while the articles remained simple text files. It meant new content could be added seamlessly without building an administration system before one was actually needed.
Building the Identity
The visual identity evolved in much the same way as the underlying code, centered around the contrast between the mechanical and the digital:
- Automaton became the past — brass, gears, and warm mechanical imagery.
- Autonomous became the present — cooler digital palettes, circuits, and software architecture.
Not every idea survived. Some logos worked in isolation but looked wrong in the header. Some hero visuals were too busy, and some layouts looked great on desktop but felt awkward on mobile. The site gradually became cleaner as we removed elements that didn't need to be there.
That highlighted another important lesson from the project: AI can generate ideas extremely quickly, but the difficult part remains deciding which ones are worth keeping.
The Content Changed the Website
The initial articles helped define what Cog & Code was becoming:
- Maillardet's Automaton anchored the historical side of the site.
- From Automata to Agents created the bridge into modern AI.
- The Workshop Opens introduced the overarching project.
Once real content existed, the site stopped being an abstract design exercise. Article listings needed thumbnails, reading time estimates became useful, social sharing links made sense, and metadata mattered. Accessibility issues became visible, and images that looked acceptable during development turned out to be far too large for production. Content directly shaped the software.
Production Ready Is Not Finished
Eventually, the site reached the point where it was technically ready to deploy. The build worked, tests passed, images were optimized, SEO and social metadata were in place, security headers were configured, and the production artifact could run independently of the source tree.
And then we put it online.
That immediately triggered another round of refinements. Seeing the live site on different physical devices exposed nuances that local development hadn't revealed: spacing changed, images were reconsidered, and navigation was reviewed once more. "Production ready" turned out not to mean "finished" — it simply meant we had finally reached the point where we could properly see what we'd built.
Who Did What?
One of the most interesting questions in an AI-assisted project is where the work actually originates. None of the roles below replaced the others — the collaboration worked precisely because they were complementary.
| Role | Contributor | Key Responsibilities |
|---|---|---|
| Direction & Judgment | Mike | Architectural vision, domain direction, local testing, editorial authority, and final decisions. |
| Design & Architecture Partner | Archie (ChatGPT) | Structural ideation, article drafting/editing, refactoring, diagnostic partner, and sanity checks. |
| Implementation Engine | Codex | Direct file editing, markup generation, component styling, and code execution. |
The human brought judgment, purpose, and responsibility. The AI brought speed, breadth, and an ability to explore possibilities without tiring. The tools turned those decisions into working software.
The First Experiment
Cog & Code wasn't originally created as an experiment in human–AI collaboration, but it naturally became one. By the time the site was ready, the process of building it had become just as compelling as the content itself.
Rather than inventing a demonstration project for the new Projects section, the obvious candidate was already sitting in front of us. Project 001 is Cog & Code. The website you are reading is both the workshop and the first product to emerge from it — and this is only the beginning.