Building Reliable AI Workflows

This is Part 2 of a series on AI adoption. Read Part 1: How to Find Value in AI for the foundation-building approach.

Over the course of about two months, I had been incorporating assistants more into my workflow—job applications, note-taking systems, a host of templates for common workflows (18+ currently). But I was ready to do more. As outlined in my previous post, I had provided as much context to my assistant as possible. Though the system prompt had a decent amount of user context, it didn't make sense to overload it with too many details. This is where individual projects come in.

Context Distribution

In both Claude and ChatGPT, projects can accept text files that assistants can use for extra context. Each of my projects hosts documents and templates related to their focus: Writing Workspace, Job Search, Software Development, Workflow Systems. Does this create the issue that I had previously? The need to keep all of these project documents in sync? Generally no. Because the most important information is contained in the Mnem system prompt. There are of course some documents that need to be shared across multiple projects, but most are self-contained, and where context/workflows need to be shared, prompt templates cover those use cases.

Strategic distribution of context across system prompt and project-specific documents

This meant figuring out what goes where—what belonged in the system prompt versus what should stay in individual project contexts. That's where you can get the most value. Because now you have an extensible system that is very effective across multiple use cases.

Website Development

So when it was time to develop my website, all the pieces were in place. Since I had spent the last few months not only building up a robust system but also building up the collaboration skills. When I researched and planned out what technologies to use, I knew to document my choices and carry those decisions forward through each phase. I had been developing my 'brand' out of necessity, so the foundation for the content was already there. All that was left to do was to iterate over design direction and colors.

Claude Code Integration Workflow

Once I had a complete outline of the website and its structure and content and had made decisions about colors and tech stack, the actual implementation workflow looked like this:

# Set up the project foundation
npx create-next-app@latest lawrencehorne-com --typescript --tailwind --eslint

# Add the design system documentation to project context
# Ask Mnem to compose a comprehensive prompt for Claude Code
# Iterate on the prompt to ensure proper configuration

# Initialize Claude Code in the repository
claude /init

# Provide the refined prompt covering:
# - Next.js 15.3 + React 19 + TypeScript 5.8 configuration
# - Design system integration with accessibility requirements
# - Component architecture with testimonial system priority
# - Performance targets and Core Web Vitals compliance

Claude Code integration workflow for systematic development

After iterating on this prompt to make sure it covered the right configuration and would get Claude Code to work the way I wanted, I provided the prompt to Claude Code and the website immediately began to take shape.

There were still times I needed to stop Claude Code and change direction, and I would do so a fair bit over the course of this project. But that initial start got things up and running fairly quickly. After all, I had taken my time improving my interactions, designing a system that provides consistent (though by no means perfect) results, I knew what I wanted, I had researched and planned. Once the project was established and had a basic website up and running, it was fun to step-by-step add to and improve what I had.

System Architecture Lessons

The progression from individual templates to project-based architecture demonstrates how engineering principles apply to this collaboration. Strategic context distribution—determining what belongs in system prompts versus external project files—creates an extensible system effective across multiple use cases.

What I learned is that figuring out what goes where makes all the difference. Core persona logic and interaction patterns stay in the system prompt. Domain-specific knowledge, templates, and workflow documentation live in project files or in text expansion automations. This separation enables both consistency and specialization without having to constantly keep everything in sync across different projects.

The website development showed that this systematic approach actually worked when I needed to build something substantial. All those months of building up the collaboration skills, understanding what I wanted, and having those quality checks in place meant I could move fast without cutting corners on quality. The entire website—from Next.js setup through component architecture to accessibility implementation—took 4 effective development days over the course of a week.

This systematic approach treats AI collaboration like any other engineering problem—with proper architecture, state management, and quality controls that scale from individual tasks to complex production projects.