# Ben McNulty — career record

AI-Enhanced Senior Software Engineer. Currently QA Automation Engineer III.

I build software across backend, frontend and testing, with a growing focus on how people and AI agents work together. I’m interested in new interfaces that make that collaboration useful and controllable, with the context, clear expectations and verification needed to get reliable work done.

Looking for: Agent and developer tooling, test and evaluation infrastructure, applied AI engineering, or senior full-stack work on AI-native teams. Florida, USA · Remote · Open to conversations.

Contact: benmcnulty@live.com · https://github.com/benmcnulty · https://www.linkedin.com/in/benmcnulty/

Canonical: https://benmcnulty.dev/ · Résumé: https://benmcnulty.dev/resume/

## Chronology

- QA Automation Engineer III: March 2022–present.
  - AI-assisted development-tooling point person for an eight-person automated regression testing team: set up Kiro, the team’s current AI tool, and own its supporting tooling, as before for Amazon Q Developer, whose version-controlled Rules, Profiles and Prompts I authored.
  - Architected the C# migration of a legacy VB.NET test suite onto a cross-driver adapter that runs Selenium or Playwright under the same test logic; the port is under way.
  - Built and shipped an internal documentation and onboarding app that consolidates the team’s scattered docs into Markdown, with a web view built from the codebase.
  - Drive weekly regression triage end to end, converting manual test paths into automated tests.
- Independent Web Developer · McNulty Web Apps: June 2018–February 2022.
  - Carried responsive full-stack client projects from the first conversation through launch and support, translating ambiguous requests into practical frontend, backend and deployment decisions.
- Frontend Engineer · Menuat: February 2016–May 2018.
  - Shipped digital menu systems from concept to cloud-hosted production, translating brand requirements into responsive, accessible experiences on low-performance, TV-connected hardware.
  - Covered project management in the interim, owning scoping, delivery and support across the client base until a permanent PM was hired.
- Independent Web Developer · McNulty Web Apps: 2012–2014. An earlier, separate period under the same business name; it overlapped Enix Networks.
- Full-Stack Developer · Enix Networks: September 2012–August 2013.
  - PHP page servers, contact forms and data handling for client sites.

## Selected proof

- Cross-driver test architecture in C#: The C# adapter I architected in my current role to run Selenium or Playwright under the same test logic: the interface contract, backward-compatible release gates, parity tests, and where assistants are and are not trusted. ([Cross-Driver Test Architecture](https://benlive.tv/blog/cross-driver-test-architecture-migrating-enterprise-qa-with-ai/) (Current role))
- Resilience for a live AI feature: Fallback chain, circuit breaker, layer-specific retries, cost allowlist and a privacy-preserving rate limiter, each traced to a real failure on my own site. ([Production Resilience Patterns for AI-Powered Features](https://benlive.tv/blog/production-resilience-patterns-for-ai-powered-features/) (Personal project))
- AI Lab: tools for working with AI: Personal tools for recruiter chat, prompt refinement, problem solving and agent configuration, designed around clear expectations and reviewable results. ([AI Lab](https://benlive.tv/ai-lab/) (Personal project))
- Orgos: an agent-first organizational OS: A personal agent-first OS I’m building: agent identities, memory, files and flow sequencing live on disk as readable JSON and Markdown, with inference dispatched through an observable queue. ([Orgos on GitHub](https://github.com/benmcnulty/orgos) (Personal project))
- Version-controlled assistant rules: The Rules, Profiles and Prompts I authored for my QA team, how edits to them are reviewed like code, and how new rules grow out of failures. ([Version-Controlled AI Governance for Engineering Teams](https://benlive.tv/blog/version-controlled-ai-governance-for-engineering-teams/) (Current role))
- The whole delivery surface, directed and owned: I designed the serverless backend, accessible vanilla-JS frontend, cross-browser tests, media pipeline and gated deploy, and I review and maintain them; AI coding assistants carried out the plans I approved. ([Shipping AI Features End to End as a Solo Engineer](https://benlive.tv/blog/shipping-ai-features-end-to-end-as-a-solo-engineer/) (Personal project))
- Clear expectations for collaborative AI: Versioned prompt contracts, sessions that can be rewound, and clear control states help people guide agents and inspect their work. ([AI Lab Part 3: Problem Solver](https://benlive.tv/blog/ai-lab-project-building-part-3-problem-solver/) (Personal project))

## Capabilities

### 01. AI-assisted engineering workflow

I work with agents by giving them relevant skills, context and clear expectations, then checking what they produce. My current personal work spans dots, Claude Duet and Muse; Claude Code and Codex are my primary direct coding interfaces. Earlier projects include Local Crew, a local-model orchestrator.

- Give agents the relevant project context, skills and working agreements
- Choose the interface and model for the work, with a clear handoff between agents
- Make requests, constraints and expected results explicit before a run
- Let agents carry work forward within agreed boundaries
- Keep changes reviewable and check the result against the request
- Record what changed, what was verified and what remains open

Tools and methods: Claude Code, Codex, dots, Claude Duet, Muse, Ollama, Kiro, Amazon Q Developer, GitHub Copilot.

Useful for teams that are adopting AI coding assistants and want reviewable diffs, explicit authority and verified handoffs rather than unbounded agent output.

Evidence: [Models and Harnesses](https://benlive.tv/blog/models-and-harnesses/) (First-person writing); [A CLI Agent Harness Playbook](https://benlive.tv/blog/cli-agent-harness-playbook/) (First-person writing); [Designing past the AI template, prompt by prompt](https://benlive.tv/blog/designing-past-the-ai-template/) (Personal project); [Building Local Crew](https://benlive.tv/blog/building-local-crew-port/) (Personal project).

Scope: At work I set up Kiro, the QA team’s current AI tool, and own its supporting tooling, as I did for Amazon Q Developer before it; that and the AI-assisted porting in the driver migration are QA-team scope. GitHub Copilot is my personal VS Code experience, going back to its beta. Everything else here is personal practice on my own projects and public site.

### 02. Context engineering and team AI rules

I turn scattered information into context people and agents can use. For an eight-person automated regression testing team, I set up Kiro and own its supporting tooling, as I did for Amazon Q Developer. I codify internal engineering standards and procedures in agent-usable documentation, and built a documentation app that brings team material into Markdown and a web view.

- Rules, Profiles and Prompts reviewed in pull requests like code
- A regression an assistant introduces becomes a new rule
- One documentation path for new engineers and new assistant sessions
- One canonical policy file that each assistant’s instruction file points to
- Docs change in the same pass as the behavior they describe
- Agent-facing guides such as llms.txt generated from one manifest

Tools and methods: Amazon Q Developer Rules, Profiles & Prompts, Kiro, CLAUDE.md, AGENTS.md, Claude Code skills, Markdown, llms.txt.

Useful for teams that keep knowledge in people’s heads or scattered docs, and want new engineers and new assistant sessions to start from the same reviewed context.

Evidence: [Version-Controlled AI Governance for Engineering Teams](https://benlive.tv/blog/version-controlled-ai-governance-for-engineering-teams/) (Current role); [Context Engineering: The Skill That Makes AI Assistants Useful](https://benlive.tv/blog/context-engineering-the-skill-that-makes-ai-assistants-useful/) (First-person writing); [Meta Programming the Workflow](https://benlive.tv/blog/meta-programming-the-workflow-context-and-agent-orchestration/) (First-person writing).

Scope: The Amazon Q Developer Rules, Profiles and Prompts, the Kiro tooling and the internal documentation app are QA-team work for my current employer. The canonical CLAUDE.md and AGENTS.md pattern, Claude Code skills and the llms.txt manifest come from my personal projects.

### 03. Verification and test architecture

I start with a question: how could this passing result be false? At work, I architected a legacy suite’s move to C# on an adapter that runs the same tests through Selenium or Playwright. The port is under way. In my personal AI Lab, I audit test runners so interrupted batches cannot report success, and turn bugs I find into automated checks.

- Test runners audited so a killed batch cannot report green
- Every hand-found bug becomes an automated check
- Test logic never knows which browser driver runs underneath it
- Ported tests keep running on the original driver until a switch is judged safe
- Page objects expose intent, not locators and waits
- Weekly regression triage, driven end to end

Tools and methods: C#, Playwright, Selenium WebDriver, Cross-driver adapter, Page objects, axe-core, Firebase Emulator.

Useful for teams that carry a legacy suite, are changing drivers or frameworks, or are letting AI assistants touch code, and need a passing build to mean something.

Evidence: [Cross-Driver Test Architecture](https://benlive.tv/blog/cross-driver-test-architecture-migrating-enterprise-qa-with-ai/) (Current role); [AI Lab Part 1: AI Chat](https://benlive.tv/blog/ai-lab-project-building-part-1-ai-chat/) (Personal project); [Shipping AI Features End to End as a Solo Engineer](https://benlive.tv/blog/shipping-ai-features-end-to-end-as-a-solo-engineer/) (Personal project); [A CLI Agent Harness Playbook](https://benlive.tv/blog/cli-agent-harness-playbook/) (First-person writing).

Scope: The adapter migration and regression triage belong to my current QA Automation Engineer III role. Runner audits, cross-browser suites and the bug-to-check rule come from my personal AI Lab.

### 04. Reliable, honest LLM features

I build AI features with clear expectations, visible results and room for the person to direct the work. In my personal AI Lab, chat replies name the model that answered; versioned prompt contracts keep behavior explicit; and an allowlisted model chain with a circuit breaker is designed to return an answer from a smaller model rather than fail.

- Clear expectations and versioned prompt contracts that make agent behavior reviewable
- Chat replies labeled with the model that actually answered
- Allowlisted models, a fallback chain and a per-model circuit breaker
- System prompts kept server-side behind versioned prompt keys
- Separate server and client retry policies, each traced to a real failure
- Interfaces that help people guide the work, inspect results and build trust

Tools and methods: OpenRouter, Ollama, Firebase Functions.

Useful for teams that put language models in front of users, where cost control, honest attribution, privacy boundaries and graceful degradation have to be designed in from the start.

Evidence: [AI Lab Part 1: AI Chat](https://benlive.tv/blog/ai-lab-project-building-part-1-ai-chat/) (Personal project); [AI Lab Part 3: Problem Solver](https://benlive.tv/blog/ai-lab-project-building-part-3-problem-solver/) (Personal project); [AI Lab Part 4: Agent Agenda](https://benlive.tv/blog/ai-lab-project-building-part-4-agent-agenda/) (Personal project); [Production Resilience Patterns for AI-Powered Features](https://benlive.tv/blog/production-resilience-patterns-for-ai-powered-features/) (Personal project).

Scope: Personal AI Lab work on my own public site.

### 05. Full-stack product delivery

I take web products from the first request through deployment and support, in TypeScript, JavaScript, React, Next.js, Node.js, C# and PHP. As an independent developer I carried client projects from the first conversation to support; earlier I built PHP client sites at Enix Networks. My recent personal work includes a serverless AI backend that I designed, built with AI coding assistants and maintain as its only engineer.

- Serverless backends on Firebase Functions and Firestore
- Rate limiting keyed on an HMAC of the visitor’s IP, never the raw address
- Personal-site deploys gated by model probes and post-deploy smoke checks
- One shared module where a configuration had been forked
- Client delivery from first conversation through deployment and support
- PHP page servers, contact forms and data handling

Tools and methods: TypeScript, JavaScript, React, Next.js, Node.js, C#, PHP, REST APIs, SQL/NoSQL, Firebase.

Useful for teams that need one engineer to carry a feature across backend, frontend, tests and deploy, and to explain the tradeoffs between those layers.

Evidence: [Shipping AI Features End to End as a Solo Engineer](https://benlive.tv/blog/shipping-ai-features-end-to-end-as-a-solo-engineer/) (Personal project); [Production Resilience Patterns for AI-Powered Features](https://benlive.tv/blog/production-resilience-patterns-for-ai-powered-features/) (Personal project).

Scope: The Firebase and serverless work is my personal AI Lab. Independent Web Developer, June 2018–February 2022. Full-Stack Developer at Enix Networks, September 2012–August 2013.

### 06. Interface, motion and spatial UI

I build responsive, accessible interfaces, from advanced CSS and design systems to spatial UI. At Menuat I shipped animated digital menu systems on low-performance, TV-connected hardware. For my own site I directed a Codex-assisted rebuild of a Three.js and WebXR gallery, with hand-tracking grabs, intent-safe teleport and an AR miniature, and kept a route that needs no 3D.

- Animated digital menu systems designed for constrained, TV-connected hardware
- Brand requirements translated into responsive on-screen experiences
- Hand-tracking grabs, intent-safe teleport and a hand-held AR view
- Design systems built on oklch, clamp() type and container queries
- Contrast checked in both themes; focus kept keyboard-safe
- A stable, readable reduced-motion version of every effect

Tools and methods: CSS, Three.js, WebXR, ARIA, Container queries, oklch, cannon-es.

Useful for teams that build visual or immersive products that must stay readable, accessible and smooth on real devices, not only in a desktop browser.

Evidence: [Rebuilding my WebXR portfolio, one headset test at a time](https://benlive.tv/blog/rebuilding-my-webxr-portfolio/) (Personal project); [Designing past the AI template, prompt by prompt](https://benlive.tv/blog/designing-past-the-ai-template/) (Personal project).

Scope: Frontend Engineer at Menuat, February 2016–May 2018. The WebXR gallery and site visuals are personal, AI-assisted projects that I directed and verified.

### 07. Communication and handoffs

I connect the people and disciplines a project needs: users, design, frontend, backend and testing. At Menuat I was the frontend intermediary between users, design and backend. I make expectations clear, write down decisions and leave handoffs someone else can pick up; those habits also shape how I collaborate with agents.

- Every run ends with a handoff: what changed, what was verified, what was not
- Decision logs record why, so settled questions stay settled
- Handoffs designed so a qualified stranger could continue safely
- Briefs that ask for plain, action-first on-screen copy
- Candid retrospectives, including what did not work
- Frontend intermediary between users, design and backend at Menuat

Tools and methods: Decision logs, Handoff notes, Markdown docs, Pull-request summaries.

Useful for teams that work remotely and in writing, and need someone who leaves work in a state that other people, or assistants, can pick up.

Evidence: [A CLI Agent Harness Playbook](https://benlive.tv/blog/cli-agent-harness-playbook/) (First-person writing); [Meta Programming the Workflow](https://benlive.tv/blog/meta-programming-the-workflow-context-and-agent-orchestration/) (First-person writing); [AI Lab Part 5: Iterative Engineering with AI Assistants](https://benlive.tv/blog/ai-lab-project-building-part-5-iterative-engineering-with-ai-assistants/) (Personal project).

Scope: Frontend Engineer at Menuat, February 2016–May 2018. The rest is practice shown in my own writing and projects.

## Where the skills meet

- C01 Test architecture × AI workflow: Assistants work inside the test contract. Alongside the driver migration, I codify the team’s internal engineering standards and procedures in documentation agents can use. The versioned Rules and Profiles make the adapter contract and expected checks explicit; people own the architecture and release decisions. Evidence: [Cross-Driver Test Architecture](https://benlive.tv/blog/cross-driver-test-architecture-migrating-enterprise-qa-with-ai/) (Current role).
- C02 Context & team rules × AI workflow: Harnesses judged on context hygiene. I rate a coding harness first on context hygiene: it has to read the project’s rules file on every session without anyone pasting it in. Evidence: [Models and Harnesses](https://benlive.tv/blog/models-and-harnesses/) (First-person writing).
- C03 Context & team rules × Test architecture: Rules that require tests. The QA team’s repository-owned AI rules require every behavior change to arrive with its matching test update, and changes to those rules are reviewed in pull requests. Evidence: [Version-Controlled AI Governance for Engineering Teams](https://benlive.tv/blog/version-controlled-ai-governance-for-engineering-teams/) (Current role).
- C04 AI product reliability × Test architecture: User-gated AI that stays testable. Each model call waits for a click, so end-to-end tests can mock the model and assert the control state at every step. Those tests check the controls; the model’s variable answers are a separate question. Evidence: [AI Lab Part 3: Problem Solver](https://benlive.tv/blog/ai-lab-project-building-part-3-problem-solver/) (Personal project).
- C05 AI product reliability × Full-stack delivery: Abuse protection that respects privacy. The public chat’s rate limiter keys on an HMAC of the visitor’s IP under a secret salt, so raw addresses are never stored or logged. Evidence: [Production Resilience Patterns for AI-Powered Features](https://benlive.tv/blog/production-resilience-patterns-for-ai-powered-features/) (Personal project).
- C06 AI product reliability × AI workflow: Model choice that plans for failure. The rule I use to pick models, the cheapest one that clears the bar for the task, with a fallback, reproduced locally before shipping, is the rule the public chat runs on. Evidence: [Models and Harnesses](https://benlive.tv/blog/models-and-harnesses/) (First-person writing).
- C07 AI product reliability × Interface & spatial: A user-triggered editor, still under test. Promptpad shipped a user-triggered inference loop, a revision model and a polished editor together, and the interface stayed testable. Evidence: [AI Lab Part 2: Promptpad](https://benlive.tv/blog/ai-lab-project-building-part-2-promptpad/) (Personal project).
- C08 Interface & spatial × Test architecture: Automated checks for spatial interaction. Automated checks cover the WebXR gallery’s hand gestures, teleporting and AR entry and exit; headset sessions then look for what the tests missed. Evidence: [Rebuilding my WebXR portfolio, one headset test at a time](https://benlive.tv/blog/rebuilding-my-webxr-portfolio/) (Personal project).
- C09 AI workflow × Interface & spatial: Directing AI design, judged on device. For the October polish pass on my site, I directed the work and judged each change on my phone; Claude did the design and engineering. Evidence: [Designing past the AI template, prompt by prompt](https://benlive.tv/blog/designing-past-the-ai-template/) (Personal project).
- C10 Full-stack delivery × AI workflow: Assistants run the loop; I own the outcome. Across my AI Lab’s delivery surface, assistants carry context and execute plans I have approved. I decide what to build, set the constraints, review the plan and the diff, and own the outcome. Evidence: [Shipping AI Features End to End as a Solo Engineer](https://benlive.tv/blog/shipping-ai-features-end-to-end-as-a-solo-engineer/) (Personal project).
- C11 Full-stack delivery × Test architecture: Deploys gated by probes and smoke checks. Before each release of my personal site, the deploy path probes every live model with a tiny request; afterward a smoke script checks status codes and headers. Evidence: [Shipping AI Features End to End as a Solo Engineer](https://benlive.tv/blog/shipping-ai-features-end-to-end-as-a-solo-engineer/) (Personal project).
- C12 Context & team rules × AI product reliability: System prompts stay on the server. AI Lab apps send a prompt key, never a prompt, so system prompts are not shipped to the browser and a visitor can choose only from allowed keys. That narrows what a visitor controls; it is not a guarantee against prompt injection. Evidence: [Context Engineering: The Skill That Makes AI Assistants Useful](https://benlive.tv/blog/context-engineering-the-skill-that-makes-ai-assistants-useful/) (First-person writing).
- C13 Collaboration × Interface & spatial: Plain language on screen. In the brief for my site’s launch reel I asked for implementation jargon to be replaced with plain language that tells the viewer what they can do, then reviewed the on-screen copy Claude rewrote. Evidence: [Designing past the AI template, prompt by prompt](https://benlive.tv/blog/designing-past-the-ai-template/) (Personal project).
- C14 Collaboration × Test architecture: Handoffs that say what was not verified. A run is not finished until its handoff lists the files changed, what was verified and what was not. Evidence: [A CLI Agent Harness Playbook](https://benlive.tv/blog/cli-agent-harness-playbook/) (First-person writing).
- C15 Collaboration × Context & team rules: Decisions that stay decided. A decision log records why each choice was made, so the next person or assistant session starts from settled decisions. Evidence: [AI Lab Part 5: Iterative Engineering with AI Assistants](https://benlive.tv/blog/ai-lab-project-building-part-5-iterative-engineering-with-ai-assistants/) (Personal project).
- C16 Collaboration × AI workflow: Handoffs a stranger could continue. I design each agent run to end in a handoff that a qualified stranger, person or assistant, could pick up safely. Evidence: [Meta Programming the Workflow](https://benlive.tv/blog/meta-programming-the-workflow-context-and-agent-orchestration/) (First-person writing).

## Working principles

- Ask how a green result could be false: A runner that treats a killed process as a pass looks green right up until it matters, so every passing result has to be honest about how it could be wrong. ([A CLI Agent Harness Playbook](https://benlive.tv/blog/cli-agent-harness-playbook/) (First-person writing))
- Harness before model: I choose the working loop first, judging its context, change control, verification and handoff, and only then debate which model runs inside it. ([Models and Harnesses](https://benlive.tv/blog/models-and-harnesses/) (First-person writing))
- Context decides the result: Model quality sets a ceiling. The context an assistant starts with decides how close the work gets to it. ([Context Engineering: The Skill That Makes AI Assistants Useful](https://benlive.tv/blog/context-engineering-the-skill-that-makes-ai-assistants-useful/) (First-person writing))
- Write the team’s AI rules down: Every team using assistants already has rules. They belong in a reviewed file, not in each engineer’s habits. ([Version-Controlled AI Governance for Engineering Teams](https://benlive.tv/blog/version-controlled-ai-governance-for-engineering-teams/) (Current role))
- Spend inference only on request: My AI Lab apps do not spend a generation the user did not ask for; the person deciding what happens next is the interface, not a limitation on the AI. ([AI Lab Part 3: Problem Solver](https://benlive.tv/blog/ai-lab-project-building-part-3-problem-solver/) (Personal project))
- Degraded, not down: A visitor should get an answer from a smaller model before they get an error from a bigger one. ([Production Resilience Patterns for AI-Powered Features](https://benlive.tv/blog/production-resilience-patterns-for-ai-powered-features/) (Personal project))
- A stale document is a bug: Assistants execute against documentation the way they execute against code, so docs change in the same pass as the behavior they describe. ([Meta Programming the Workflow](https://benlive.tv/blog/meta-programming-the-workflow-context-and-agent-orchestration/) (First-person writing))

## Team fit

- Engineering teams formalizing how they work with AI assistants: Assistant rules, prompts and review practice versioned in the repository, with harness and model choices made per task. For an eight-person automated regression testing team I am the AI-assisted development-tooling point person and authored its Rules, Profiles and Prompts.
- Product teams shipping LLM features to real users: Allowlisted models, fallbacks, honest attribution and privacy boundaries have to be designed together with a tested full-stack implementation.
- Test-infrastructure teams modernizing a legacy suite: Frameworks or drivers are changing under existing coverage, release gates have to hold during the change, and assistants need written rules before they touch tests.
- Product teams that need a senior full-stack engineer: One engineer carries a feature across backend, frontend, tests and deploy, and can explain the tradeoffs between those layers.

## Perspectives

### Overview

Current role first, then earlier full-stack and frontend roles; personal AI projects are labeled as personal throughout.

### AI tooling

At work, I set up Kiro and own its supporting tooling for an eight-person automated regression testing team, following the same work with Amazon Q Developer. Personally, I work with dots, Claude Duet and Muse alongside Claude Code and Codex, and build AI Lab tools for chat, prompt refinement and agent configuration.

### Test infrastructure

QA Automation Engineer III, March 2022–present. I designed the C# cross-driver adapter a legacy suite is moving onto, so the same tests run on Selenium or Playwright, and I drive weekly regression triage end to end.

### Full-stack delivery

I carry client projects from the first conversation through deployment and support. My experience spans independent full-stack work, frontend delivery at Menuat and PHP client sites at Enix Networks. In my personal AI Lab, I direct and verify AI-assisted work across the frontend and backend.

### Frontend engineering

At Menuat, I shipped digital menu systems from concept to cloud-hosted production, tuned for low-performance, TV-connected hardware. More recently, I directed and verified a Codex-assisted Three.js and WebXR gallery rebuild for my personal site.

### Ownership

As QA Automation Engineer III, I am the AI-assisted development-tooling point person for an eight-person automated regression testing team and drive weekly regression triage end to end. At Menuat I covered project management until a permanent PM was hired, owning scoping, delivery and support.

## Existing work

- [Context-first work](https://benlive.tv/context-first/) (Personal project)
- [AI Lab](https://benlive.tv/ai-lab/) (Personal project)
- [Development portfolio](https://benlive.tv/portfolio/) (Personal project)
- [Earlier résumé on BenLive (older wording)](https://benlive.tv/about/) (First-person writing)
- [Cross-Driver Test Architecture](https://benlive.tv/blog/cross-driver-test-architecture-migrating-enterprise-qa-with-ai/) (Current role)
- [Version-Controlled AI Governance for Engineering Teams](https://benlive.tv/blog/version-controlled-ai-governance-for-engineering-teams/) (Current role)
- [Context Engineering: The Skill That Makes AI Assistants Useful](https://benlive.tv/blog/context-engineering-the-skill-that-makes-ai-assistants-useful/) (First-person writing)
- [Models and Harnesses](https://benlive.tv/blog/models-and-harnesses/) (First-person writing)
- [A CLI Agent Harness Playbook](https://benlive.tv/blog/cli-agent-harness-playbook/) (First-person writing)
- [Meta Programming the Workflow](https://benlive.tv/blog/meta-programming-the-workflow-context-and-agent-orchestration/) (First-person writing)
- [Building Local Crew](https://benlive.tv/blog/building-local-crew-port/) (Personal project)
- [Production Resilience Patterns for AI-Powered Features](https://benlive.tv/blog/production-resilience-patterns-for-ai-powered-features/) (Personal project)
- [Shipping AI Features End to End as a Solo Engineer](https://benlive.tv/blog/shipping-ai-features-end-to-end-as-a-solo-engineer/) (Personal project)
- [AI Lab Part 1: AI Chat](https://benlive.tv/blog/ai-lab-project-building-part-1-ai-chat/) (Personal project)
- [AI Lab Part 2: Promptpad](https://benlive.tv/blog/ai-lab-project-building-part-2-promptpad/) (Personal project)
- [AI Lab Part 3: Problem Solver](https://benlive.tv/blog/ai-lab-project-building-part-3-problem-solver/) (Personal project)
- [AI Lab Part 4: Agent Agenda](https://benlive.tv/blog/ai-lab-project-building-part-4-agent-agenda/) (Personal project)
- [AI Lab Part 5: Iterative Engineering with AI Assistants](https://benlive.tv/blog/ai-lab-project-building-part-5-iterative-engineering-with-ai-assistants/) (Personal project)
- [Rebuilding my WebXR portfolio, one headset test at a time](https://benlive.tv/blog/rebuilding-my-webxr-portfolio/) (Personal project)
- [Designing past the AI template, prompt by prompt](https://benlive.tv/blog/designing-past-the-ai-template/) (Personal project)
- [Orgos on GitHub](https://github.com/benmcnulty/orgos) (Personal project)
- [Local Crew on GitHub](https://github.com/benmcnulty/localcrew) (Personal project)
- [Promptpad on GitHub](https://github.com/benmcnulty/promptpad) (Personal project)
- [Synthetic Data on GitHub](https://github.com/benmcnulty/synthetic-data) (Personal project)
- [Stay Ahead on GitHub](https://github.com/benmcnulty/stay-ahead) (Personal project)

## Contact

benmcnulty@live.com
