How I Use AI

AI is a core part of how I build software. I use it as a development partner, not a replacement — for writing code, reviewing architecture, automating content pipelines, and shipping faster without cutting corners.

What I Use

Claude Code

My primary coding tool. I use it for building features, debugging, architecture decisions, code review, SEO auditing, accessibility fixes, and performance optimization. Every active project has a CLAUDE.md file that gives Claude full context on the codebase.

Anthropic API

Integrated directly into production applications. Claude generates articles, extracts metadata, and processes content in batches — with human review at every step.

How I Use It

Full-Stack Development

Building features end-to-end — from database schemas to UI components. Claude Code handles the implementation while I focus on architecture and product decisions.

Content Automation

Automated pipelines that pull from social feeds, generate SEO-optimized articles, and publish to production. Quality guardrails ensure nothing ships without validation.

Planning & Architecture

Breaking down complex projects into implementation plans, evaluating tradeoffs, and mapping out migrations before writing a single line of code.

Project Memory

I maintain detailed context files and memory systems across projects so AI retains architectural decisions, hard-won lessons, and domain knowledge between sessions.

Planning & Migrations

Before I write code, I use AI to think through the plan. For new projects, that means mapping out the data model, API surface, and component hierarchy. For migrations, it means understanding every dependency, every breaking change, and every rollback path before touching a line of code.

Portfolio: Next.js to Astro 6

Migrated this portfolio from Next.js to Astro 6 — a full framework swap. I used Claude Code to audit the existing codebase, map every route and data dependency, plan the content pipeline migration from local MDX to Contentful-powered generation, and identify which patterns would translate directly versus what needed to be rethought. The CLAUDE.md file became the migration spec: routes, content schema, environment variables, and deployment config all documented before the first commit.

Client Platform: Netlify to Vercel

Migrated a multi-property real estate platform from Netlify to Vercel while simultaneously upgrading the Astro framework version. Claude Code helped analyze the existing deployment config, identify Netlify-specific features that needed Vercel equivalents, and plan the DNS cutover. I maintained 15+ memory files tracking domain mappings, CMS backup procedures, and architectural decisions across the migration — so every session picked up exactly where the last one left off.

How I plan with AI

I don't ask AI to "plan a migration." I feed it the codebase via CLAUDE.md, describe the target state, and work through the plan iteratively — challenging assumptions, stress-testing edge cases, and building a step-by-step checklist. The plan lives in the conversation until it's solid, then gets committed as documentation. By the time I start coding, the hard decisions are already made.

Quality Assurance

I use AI to systematically audit and improve five quality dimensions across every project. This isn't a one-time pass — it's how I work. After features ship, I run AI-assisted audits to catch what I missed and fix it before users notice.

Performance

Audit Core Web Vitals and Lighthouse scores, then fix what matters — not just chase green numbers

Optimize image delivery with modern formats (AVIF, WebP) and responsive sizing via CDN parameters

Defer third-party scripts like analytics so they don't block first paint

Set aggressive cache headers for hashed build assets and static files

Enable prefetching for instant-feeling page navigation

SEO

Diagnose indexing issues in Google Search Console — crawl errors, redirect chains, canonical mismatches

Implement structured data (JSON-LD) for rich search results — Article, FAQPage, BreadcrumbList, Person schemas

Add Open Graph and Twitter meta tags with proper og:type differentiation

Generate and validate sitemaps, configure robots.txt, and fix trailing slash inconsistencies

Normalize canonical URLs across www/non-www and trailing slash variants

Accessibility

Add skip-to-content links, proper focus-visible outlines, and keyboard navigation support

Fix heading hierarchy — no skipped levels, semantic document structure

Implement ARIA attributes: aria-live for dynamic content, aria-pressed for toggle buttons, aria-hidden for decorative elements

Add screen reader text for external links and icon-only controls

Respect prefers-reduced-motion by disabling animations and scroll behavior

Content Quality

Set model-tier quality floors — capable models for body content, fast models for metadata only

Enforce "never fabricate" rules in AI configurations to prevent hallucinated content

Validate AI-generated HTML for proper structure before publishing

Run human review on every piece of generated content before it hits production

Monitor for quality signals — content flagged by search engines gets investigated and the pipeline gets adjusted

Best Practices

Run full Lighthouse audits across Performance, Accessibility, Best Practices, and SEO categories

Fix issues systematically — heading order, image dimensions, cache policies, render-blocking resources

Maintain CLAUDE.md files as living documentation so every AI session starts with full project context

Track decisions in memory files so hard-won lessons carry forward across sessions and projects

Review every AI-generated commit before pushing — I own what ships

Used Claude Code to onboard onto each codebase rapidly. Built comprehensive CLAUDE.md files documenting the architecture, deployment config, CMS structure, and domain mappings for every property. Executed platform migrations (Netlify to Vercel), framework upgrades, and ongoing feature development — all while maintaining the memory system that made context-switching between properties seamless.

Context at Scale

This project has the most extensive memory system of anything I've worked on — 15+ files tracking domain configurations, security considerations, CMS backup procedures, architectural decisions, and client preferences. When I switch from one property to another, Claude Code picks up the full context immediately. No re-onboarding, no searching through old Slack threads. The memory system pays for itself every time I open a different repo.

How I Think About It

Human in the loop

AI generates, I review. Nothing ships to production without my sign-off — especially content. I set explicit rules like "never fabricate" in my AI configurations.

Context is everything

Every project gets a CLAUDE.md with architecture docs, constraints, and conventions. Memory files capture lessons learned so context carries across sessions, not just within them.

Quality floors

I set minimum model tiers for different tasks. Quick metadata extraction can use a fast model. Article generation needs a capable one. I learned this the hard way when lower-tier output got flagged by Google.