Portfolio

Selected AI engineering work — production AI platform, customer-facing pursuit microsite pattern, token-efficient Claude Code corpus design, and supporting primitives.

Sanitized for public publication. Customer names, internal product names, employee names, and specific deal amounts removed. Patterns and methods preserved.

Public résumé: /michael-tuszynski/ ·  Blog: The Cloud Codex

What I build

Production AI systems for engineering and revenue teams — focusing on versioned, auditable platforms with guardrails, evaluations, and real adoption rather than demos. Current platform work codifies a Fortune-1000 professional services org's pursuit lifecycle as an internal AI platform: a Claude Code plugin marketplace orchestrating Salesforce, Microsoft 365, OneDrive, Anthropic Claude, and AWS Bedrock.

AI engineering platform (in production, 9+ months)

An AI-native operating system for enterprise presales pursuits covering discovery, qualification, statement-of-work lifecycle, risk review, and engagement handoff on a single context store.

Scale at last cut:

  • 11 plugins, 60+ slash commands, 562 passing tests
  • ~51K LOC TypeScript
  • Multi-provider model routing (Anthropic Claude primary, AWS Bedrock fallback) with env-var toggle
  • Prompt-contract framework with versioned input/output schemas
  • Evidence-citation guardrails: High/Medium/Low confidence + dated source URLs required on every claim
  • Session-start hooks hot-loading operational knowledge from synced channels
  • Prompt caching for shared guardrails and knowledge base
  • Per-command rule contracts; provider switching via environment variable

Outcomes (anonymized):

  • Compressed manual artifact production hours into command-driven workflows
  • Enabled $0.5M+ and $1M+ enterprise engagements to close on platform-authored statements of work with iterative revisions
  • Partner-funded engagement program added co-funding to a pursuit
  • Productized AI Well-Architected workshop at small-five-figure list price; first paying customer in flight

The pattern: start shipping custom for one customer, then extract patterns into a framework for ten field engineers.

Customer-facing pursuit microsite pattern

Built a customer-facing pursuit microsite in days for an enterprise AI agent engagement in K-12 EdTech using Claude-on-platform. The microsite anchored follow-up conversations with the client's CEO and hyperscaler co-sell partner; the pursuit moved from ideation workshop to verbal Phase-1 commitment in three weeks.

Pattern observations:

  • AI-listener-agent architecture on AWS Bedrock + ECS Fargate behind WebSocket API Gateway, with OpenSearch Serverless for RAG and Transcribe/Polly for voice
  • POC built live in ideation workshop (single-file Flask + Anthropic, ~3,700 lines, eight views) served as conversation piece pulling stakeholders into architecture discussions faster than slides
  • Microsite + POC + workshop collapsed what used to be three serial deliverables into parallel motion

The artifact pattern is portable: AI pursuit microsites are cheap to build, land differently than decks, and serve as persistent reference points through Phase-1/Phase-2 sequencing.

Token-efficient Claude Code corpus design

A reproducible methodology for keeping a multi-plugin Claude Code corpus lean. Took a production corpus from 221K tokens → 179K tokens (19% reduction) without removing procedural steps or contract terms.

The numbers:

PoolBeforeAfterSaved%
Commands (per invocation)146,105111,140−34,965−23.9%
Rules (auto-load every session)18,37514,478−3,897−21.2%
Skills (per invocation)56,62053,815−2,805−5.0%
Total221,100179,433−41,667−18.8%

Token counts via tiktoken / cl100k_base — close proxy for Anthropic tokenization.

Why it matters:

  • Context-window headroom on every command
  • Faster first-token latency
  • Cleaner prompts drive better instruction adherence
  • Linear scaling — doubled users means doubled savings

Seven patterns that drove the savings:

  1. Rules dedup is the cheapest 4K tokens you'll find. Multiple plugins carried byte-identical context files. Collapsing into a shared core/rules/ directory saved ~3.9K tokens loading in every session.
  2. The top decile of commands held 42% of the command corpus. Token distribution is heavily right-skewed. Sort by tokens descending and trim the top decile.
  3. Pipeline-banner repetition is invisible but expensive. Step counters like > **Step 3 of 5** repeated at the top AND inside every subsection. Once at the top is enough. Saved ~600–1,200 tokens per affected command.
  4. Auto-resolve fallback boilerplate copy-pastes faster than it earns. Six-bullet "if exactly one... if zero, stop and ask... if multiple, stop and ask..." blocks collapsed to one sentence. Saved ~400 tokens per command.
  5. Multi-format output templates with 90% overlap should be one base + deltas. If "JSON output," "markdown output," and "console output" list the same 12 fields, write one structured template and note format-specific variants as deltas.
  6. Persona reload reminders inside commands are redundant. Personas load once at session start. Reminders inside individual commands are dead weight.
  7. Skills are different — be careful what you trim. Framework specs with load-bearing prose and code (helper-class definitions, PPTX coordinates with EMU values) shouldn't be touched. Skills accounted for only 5% of savings.

Best practices for new commands:

  1. Default to terse. Most commands need 1.5K–2.5K tokens, not 5K+.
  2. Don't restate guardrails. They live in core/rules/. Reference them.
  3. Don't restate path resolution. The contract is in core/rules/.
  4. Auto-resolve fallback is one sentence.
  5. Multi-format outputs go in one template with conditional sections.
  6. Banner repetitions: once at the top, never repeat.
  7. Procedural specifics, code, and contract terms stay verbatim.

Methodology (reproducible):

  1. Baseline the corpus. A tools/token-baseline.py walks plugins/*/{commands,rules,skills}/*.md, counts tokens with tiktoken, emits CSV + XLSX with per-file detail, totals by type and plugin, top-20 sheet.
  2. Identify the top offenders. Sort by tokens descending. Top decile concentrates the savings.
  3. Audit rules for byte-identical duplication. An md5 across plugin rule files surfaces collapse candidates.
  4. Trim each targeted file. Cut redundant pre-flight prose, repeated path-resolution boilerplate, restated guardrails, banner repetitions, verbose multi-format templates. Keep procedural specifics, code, contract terms.
  5. Re-baseline after each batch. Label snapshots (baseline, after-dedup, after-top7, final). Every snapshot is auditable.

"Lean prompts compound. Cluttered prompts compound differently."

Run quarterly, or any time the corpus grows by >10% without functional additions.

Selected AI engineering primitives

  • Cross-platform OneDrive path resolver — disambiguates personal vs. organizational mount paths across macOS and Windows; survives the OneDrive rename/move dance that breaks most tooling.
  • Prompt-contract framework — versioned input/output schemas per command, with contract violations surfacing in the developer console rather than degrading silently.
  • Evidence-citation + confidence-disclosure guardrails — every claim in generated output must cite a dated source URL and a High/Medium/Low confidence rating; outputs refuse to generate if they can't satisfy the contract.
  • Session-start hook that hot-loads operational knowledge — institutional memory becomes ambient without requiring a plugin release; the ops team can update guidance in a synced channel and the next session picks it up.
  • Multi-provider AI infrastructure — Anthropic Claude (primary) with AWS Bedrock fallback; prompt caching for shared guardrails and knowledge base; per-command rule contracts; provider switching via env-var toggle.
  • :council multi-agent advisory pattern — pressure-tests recommendations through a 5-advisor council before reaching the user; surfaces dissent that single-agent flows hide.
  • Document generation pipeline — branded Microsoft Word output via AI-augmented markdown rendering; preserves enterprise template fidelity while generating from structured content.

Background

25 years in engineering leadership and platform work. Former CTO of a streaming platform (20+ person team, $4MM+ budget, 99.98% uptime, 100% YoY user growth, monolith-to-microservices migration). Six years as Senior Solutions Architect at AWS — co-authored theECS Workshop (canonical hands-on container workshop), featured speaker on theAWS re:Think Podcaston cost optimization.

UC Berkeley Executive Education — Professional Certificate in Machine Learning and Artificial Intelligence (2025). Harvard Data Science Review — Agentic AI Intensive (December 2025). AWS Certified Solutions Architect Professional + DevOps Engineer Professional.

Personal AI lab — NEXUS

Multi-machine personal R&D workspace prototyping patterns for client work. NAS + Mac-mini + laptop topology with ~7 production services (TypeScript/Node), 18+ LaunchAgents, a custom Slack bot with auto-discovered slash commands, semantic search over conversation history (Ollama embeddings), self-hosted dashboards behind Cloudflare Tunnels, and integrations with Anthropic Claude, Plaid, Microsoft 365, Synology DSM, GitHub, and Ghost CMS. Test bed for prompt-contract patterns, agent orchestration, hot-loaded knowledge, and evaluation harnesses deployed to enterprise engagements.

Public writing

Inquiries: mike@mpt.solutions ·415-793-4717 ·Full résumé (PDF)

Press ESC to close.