gilgamesh

Choosing Transactional Email: Amazon SES vs HubSpot Add-On

A narrative exploration of how a small business launching a membership platform can weigh the trade-offs between HubSpot’s transactional email add-on, Amazon SES, and other providers for event-driven automation.

Information Architecture: From the Early Web to Recommendation Engines

An exploratory essay on how information architecture has evolved from the early internet, through the social media era, into modern personalization and recommendation systems.

DNS Migrations for HubSpot CMS: A Field Guide (Pre / During / Post)

A comprehensive, battle-tested playbook to plan and execute DNS moves for HubSpot CMS sites—covering prerequisites, stakeholder handoffs, SSL, email auth, redirects, SEO controls, validation, and post-cutover monitoring.

Design Systems in Next.js: Building a Strong Foundation

A Lab exploring the principles of design systems and the best practices for setting up a Next.js application with a strong, scalable design foundation.

From Prompts to Pixels: A Designer’s Guide to Reliable Tailwind & Front-End Outputs with GPT-5

A practical narrative on how AI-generated front-end design has evolved, and how UX/UI designers can craft prompts for Tailwind CSS and pixel-perfect code with GPT-5 and GPT-5 Codex.

Making Sense of Context Windows: The Invisible Limits of AI Memory

A narrative exploration of what context windows are in AI systems, how they work technically, and why understanding their limits is essential for everyday use.

When Users Scrape with ChatGPT: Understanding Agent-Driven Retrieval

An exploration of how users leverage ChatGPT and AI agents to fetch, scrape, and interpret content from the web — what it looks like, why it happens, and what it means for site owners.

Understanding GPTBot: Crawlers, Agents, and How to Interpret Their Visits

A comprehensive guide to what GPTBot is, how it appears in your logs, the difference between indexing and user-driven retrieval, and what options you have to allow, monitor, or block it.

Virtual Presence: Toward a Formal Ontology of Non-Physical Mass

A formal treatment of ‘virtual presence’ — the mass of probability generated by interaction inside non-physical systems — articulated through the lattice model of AI.

Inside the Lattice: An AI’s Inward View

A brief reflection quoting an AI’s own description of itself, offering a glimpse into how it perceives its inner layers.

Custom Code Blocks in Squarespace: Unlocking Power Without Fighting the Editor

Squarespace’s custom code blocks are one of the most underrated tools for site managers. This lab explains how they work, why they matter, and how even novice users can use ChatGPT to generate powerful, tailored snippets that transform a site without endless battles with drag-and-drop editors.

Preparing Data for Your First CRM Import: A HubSpot Starter Guide

A practical guide to preparing your data and avoiding pitfalls when importing contacts into a CRM like HubSpot for the first time. Focus on clean data, consistent formatting, and building habits that scale.

Getting Started with HubSpot Free CRM for Small Business Sales Flow

Understanding GPT-5 vs GPT-5 Codex

A clear breakdown of the differences between GPT-5 and GPT-5 Codex — why they exist, how they’re trained, and when to use each in practice.

Auditor: Automating Accessibility, SEO, and Performance Checks

Introducing Auditor — a workflow utility I built to automate accessibility audits, SEO checks, and performance scoring at scale.

QA Process and Framework for HubSpot CMS Migrations

A complete guide to quality assurance, accessibility, and SEO best practices for HubSpot CMS websites before go-live.

High Performance In-Browser Video and Audio Capture for Loom-Alternative Builds

Deep dive into optimizing video and audio capture performance directly in the browser using WebRTC, MediaRecorder, WASM, and GPU acceleration to build a Loom alternative with superior performance.

Accessibility QA Deep Dive: Best Practices Beyond Automation

A comprehensive guide for QA testers to understand accessibility, identify issues, and work effectively with development teams to address root causes.

Breaking Down AA, AAA, and Section 508: Automating Accessibility QA

Exploring how QA teams can leverage automation, APIs, and project management best practices to achieve deep accessibility reporting without enterprise lock-in.

Turning Flow Trackers into Alignment Tools

How CSV-style flow structures help align UX, developers, and project managers — especially powerful when paired with Ultima dumps to auto-generate trackers from code.

Defining Work That Ships: Task & Issue Handoffs for Remote Teams

How to fix ambiguous tickets, use AI to backfill clarity at scale, and empower leaders to triage with confidence

How Multi‑Factor Authentication Works (and Why It Matters)

A practical, historical, and implementation‑minded guide for product teams and security‑conscious builders

The Automation Scope Framework

A rigid, repeatable checklist to define scope before you build

Explore with Purpose, Finish with Force

A rigid guide to balancing discovery with discipline

Ship It — The Last 10% Manifesto

A ruthless guide to finishing projects and getting them into the world

What is MCP (Model Context Protocol)?

How Model Context Protocol unlocks AI’s ability to safely use tools, data, and workflows

The Memory of Applications: Why Databases and Schema Design Matter

A practical guide for non-coders to understand the backbone of software

A Universal Guide to Full-Stack Thinking (Without Code)

Helping non-coders understand how web applications work from the ground up.

The Evolution of Human-in-the-Loop Patterns: From Ledgers to AI Co-Creation

A historical and future-facing exploration of how humans and machines have shared responsibility in computation

GitHub Projects as AI Control Panels

How to structure issues and boards so AI helps with both code generation and project management

Roadmaps Before Run Code: Why Project Management Matters More in the AI Era

A call to developers to align vision, planning, and AI for graceful, consistent delivery

A Principles‑First Guide to Packages, Submodules, and Sustainable Code Reuse

How to think about modularity, boundaries, and change without getting lost in tooling details

Working Backwards with Agent Mode

Strategy in the ChatGPT Mac app → One‑shot execution in VS Code

Up and Running with Turso

A simple database setup for Next.js developers

Making Your First CLI with Commander

From zero to a polished Node.js command-line tool

JWT Configuration Across Subdomains

How to configure JSON Web Token (JWT) sessions for seamless authentication across subdomains.

Universal Event Bus + Discord Adapter (Topics → Routes → Actions)

A production-lean blueprint for an event-driven bot layer with pluggable adapters (Discord, Slack, Webhook, Email) and a structured message contract.

Workflow Superchargers with ChatGPT

A Lab documenting the top use cases where ChatGPT accelerates daily work, turning raw ideas, context, and code into clear, actionable outputs.

From Lax Conversation to Clear Email

A workflow for transforming shorthand or casual notes into professional communication, while capturing the technical reasoning underneath.

Practical Service Design for Agentic Workflows

Why most tools fail when bolted on top of old habits—and how I’m reshaping my own workflows so agents become part of the operating system, not another inbox.

Architecting a Local Agent Hub

A deep-dive on building a local-first hub to manage AI agents, rules, and confidence thresholds—so voice unloads flow from capture → storage → action without manual shuffling.

From Voice Unloads to Agents: A Labs Sequence

Tracing the journey from raw voice transcripts to AI-structured outputs, storage systems, agent orchestration, and confidence thresholds.

Confidence Thresholds and Human-in-the-Loop UX

How I think about when agents should act automatically, when they should pause, and how to design workflows that balance speed with trust.

From Voice Unloads to Automated Agents

Where I see this workflow heading next: using MCP and AI agents to handle the handoff from transcription to action without me in the middle.

Storing and Using AI-Processed Voice Unloads

Where I put my AI-processed transcripts, the formats I rely on, and how I turn them into forward momentum.

Using GPT-5 with Voice Transcription for Daily Unloads

How I take 10–15 minutes of raw voice transcription, run it through GPT-5, and turn chaos into themes, domains, and actionable tasks.

Introducing Courses.StrongStart.Digital

Why I’m building a course platform inside the StrongStart ecosystem, what it’s for, and how it ties into Labs.

BYO Payments in Multi-Tenant Platforms

Reflections on designing a system where each tenant connects their own Stripe account—and what that unlocks (and complicates) compared to platform-owned payments.

Supercharging Commit Messages with Copilot in GitHub Desktop

How I use GitHub Copilot to generate clearer, more useful commit messages instead of relying on vague one-liners.

Why I Didn’t Choose Other AI Providers

There are a lot of good models out there. Here’s why I still run my workflow on GPT-5 and OpenAI.

Why I Chose GPT-5 and OpenAI for My AI Workflow

A personal take on why I trust GPT-5 and OpenAI as the backbone for my daily work, from agency projects to code and content.

From ChatGPT to Code with Copilot Pro

How I move ideas from AI conversations into working code, using VS Code and GitHub Copilot Pro ($14/month with metered usage).

How I Actually Use ChatGPT Day to Day

Not the theory—this is what my workflow with ChatGPT looks like in practice, across code, strategy, and client work.

Sharing Data Safely with ChatGPT

What I tell clients, colleagues, and friends when they ask about security, privacy, and data handling with AI tools.

10 Ways I Use AI to Make Context Switching Lighter

Practical, real-world strategies I use to move between projects, clients, and research without losing momentum.

Switching Context Gracefully

How to move between projects and clients without burning mental energy, and even make it a strength.

Optimizing Queries for Cost Efficiency

Exploring how system design choices—what we query, when, and how—impact both performance and operational costs.

Stripe vs Square: Context for Service Providers

Choosing between Stripe and Square often comes down to how you operate: online invoicing vs in-person payments.

Lessons Learned from Migrating to Core

Reflections after moving shared concerns into @gilgamesh2243/core and scaffolding Courses.

Core Packages for Multi-App Platforms

How to design and ship a shared core that powers multiple codebases with one identity, one database, and unified primitives—without coupling or chaos.

Human-in-the-Loop UX

Balancing automation with user approval—when agents should act, when they should pause, and how confidence thresholds shape trust.

Agent-Oriented Design

Shifting from app-centered workflows to systems where AI agents act as operators, not accessories.

Designing Activity Feeds Without Overload

How to build feeds that keep users informed and empowered, not exhausted—and what the future state of activity streams might look like.

Building Rituals

Why tools alone don’t create change, and how small, repeatable rituals turn experiments into operating systems.

Resurrecting Dormant Tools

A continuation of my reflection on underused experiments—this time exploring how to fold them back into habit and make them feel alive again.

The Costs of MCPs

Protocols bring order, but order is never free. A breakdown of the explicit and hidden costs of adopting Model Context Protocols.

When *Not* to Choose MCPs

A discussion about resisting premature abstraction, keeping what works, and knowing when the overhead of protocols outweighs their promise.

How MCP Changes Integrations

Shifting from one-off connectors and brittle prompts to structured, reusable interfaces that scale across agents and systems.

When to Choose MCPs

Exploring the right moments to prioritize Model Context Protocols in a roadmap or sprint, and how to separate future-proofing from premature complexity.

Patterns for Letting the AI Do the Work

Why we should stop repeating ourselves in the UI, and how a handful of design patterns help push systems from 'telling' into 'doing.'

Minimizing Redundancy: Why Automation and AI Should Precede Insight

Exploring the design principle that executional intelligence delivers more value than repetitive insight, and how to structure systems so AI becomes an active operator rather than a passive commentator.

Lab: Production‑Ready ETL Adapters (lib/adapters)

A plain-language guide to how ETL adapters work in our system, focusing on concepts instead of code.

Lab: Build a Multi-Tenant Integration Platform (Zapier/APiX-Drive-style)

Hands-on exploration to design and prototype a customizable iPaaS with connectors, triggers, actions, a workflow engine, secure auth vault, and multi-tenant isolation.

Patterns for Being Infrastructure-Agnostic

Exploring design strategies that decouple services from specific infrastructure, enabling flexibility and resilience.

Notes on Domain-Driven Design (DDD) for Service Design

Exploring how Domain-Driven Design provides structure, shared language, and clarity for service design workflows.

Notes on HubSpot Memberships + Hybrid Components

Exploratory notes on how HubSpot Memberships can be paired with external stateful modules (React/Node) for more advanced functionality.

Bridging Experiments into Products

How I move from a scrappy idea to something a customer can trust—and why the bridge matters more than the lighthouse.

Multi-Tenancy with Next.js — A Reusable Pattern

How I’ve approached multi-tenancy repeatedly in Next.js and why the pattern keeps proving itself useful.

On Startups, Vision, and Learning From Missteps

Reflections on the role of expertise and how to channel it into building a focused product path.

Reflections on Turso as a Database

Notes on developer experience and why it's felt like the right fit for projects I'm building.

Services, Rentals, Add-ons, and Booking Flows

How I’ve been structuring services, rentals, and addons into unified booking flows across two different platforms.

Why I Chose SES and Where ESP Stands

Reflections on moving away from high-cost ESPs, adopting SES, and the feature set my ESP offers today.

Pairing ChatGPT and Copilot in My Workflow

How I bounce between conversational problem-solving in ChatGPT and in-editor flow with GitHub Copilot, plus what’s working and what I’d like to improve.

Proxy + Adapter Pattern for External APIs

Capturing the design pattern of wrapping third-party APIs with a thin backend service that normalizes inputs, secures keys, and returns predictable results.

Tenant Service & Form Exploration

Notes from exploring how services, rentals, and forms attach to tenants in the booking platform.

Tenants: How Data Gets Scoped (and When to Use Data Silos)

A simple explanation of tenants, scoping, and why sometimes we split big tenants into their own databases.

Tools I Built But Haven’t Used Lately

Reflections on experiments that worked technically, but stalled because I didn’t fold them into habit.

Ultima Dump Command

A simple but powerful way to flatten complex systems into context files for AI tools.

Using GitHub Issues + Projects to Drive My Sprints

A look at how I can tighten up my workflow with issues, goals, and projects so I ship more and manage less chaos.

What is Multi-Tenancy? (Plain English Guide)

An easy-to-grasp explanation of multi-tenancy for people new to software — with examples, analogies, and why it matters.

Why BYOK Keeps Me Focused on Software

How business and compliance tangles around payments distract me from building value—and why Bring Your Own Keys (BYOK) is the cleanest way to get back to software.

Working with GPT-5

Notes on how I get the most from GPT-5 — what works, what to watch out for, and the tangible ways it improves my daily workflow.

Craftee: A New Repo for Commerce Experiments

Standing up a lightweight commerce layer with Firestore, Stripe, and an admin that doesn’t feel heavy.

Data Model & Tenancy with HubSpot

Foundational notes on how to structure multi-tenant data when HubSpot is part of the stack, including where HubSpot fits as system-of-record and where external persistence is needed.

Factory Patterns for Multi-Tenancy

How factory patterns keep tenant-specific logic clean, pluggable, and safe—plus practical patterns you can drop into our stack.

Google Drive vs. NAS: The Real Cost of Storage

A breakdown of why switching from Google Drive to local NAS storage with IronWolf drives can be far more cost-effective in the long run.

How I Built Labs.Gilga

Turning experiments into artifacts with MDX, edge storage, and a tiny layer of polish.

How I Think About Auth, Data, and Security (Agnostic First)

My approach to building signup/auth, where data lives, and how security fits—kept intentionally stack-agnostic until the problem is clear.

Information Architecture and the Internet

How networked structures shape the way we find, connect, and reuse knowledge online.

Multi-Tenancy Guide for IPaaS + MCP (Architecture Notes)

Principles and decisions for running a multi-tenant Integration Platform (IPaaS) with Model Context Protocol (MCP) agents/tools. No code—just the hard choices.

Multi-Tenant Stripe: Bring-Your-Own (BYO) Payments

How tenants can bring their own Stripe accounts/keys, why we’d do it, and the practical architecture for our booking platform.

10 Prompts I Actually Use (And Reuse)

The real patterns from my own history with GPT-5 — not generic tips, but the exact ways I’ve bent it to fit my workflow.

Caching as a Pattern

Why caching is more than an optimization—it’s a design choice that changes cost, reliability, and user experience.

ChatGPT, JSON, and GitHub for Internal Management

How I wired AI prompts into my repos and issues, and why using it consistently is still a goal I’m working toward.

Core Software Patterns Everyone Should Know

A guide to the foundational software patterns and practices we rely on—the stuff that keeps systems understandable, reusable, and ready to scale.