⚡ Vincent Depatie

What I actually do all day

• Architect a subsystem, then decompose it into agent-sized contracts
• Write and review cycle-critical assembly and C
• Design data layouts: schemas, indexes, packed formats, compression
• Build gates that prove the code is correct before it ships
• Debug at the hardware level — PPU, APU, mapper, memory map

Why the unusual profile

• 14 years of hospitality operations and management before code — budgets, staffing, deadlines
• 5 years of frontline clinical practice — protocol discipline and zero-error handover
• Those two trains me to work under constraints where a mistake is visible and expensive
• Engineering is the third career, and the one I chose deliberately

I — Engineering school (ÉTS, Montréal)

• Studies in Operations & Logistics Engineering — ÉTS Montréal, not completed
• Learned to program in C and JavaScript
• Hands-on hardware: circuit wiring, code injected into microchips, servo control
• CNC machining: writing G-code and running the machine

II — Resort operations (Haiti)

• Kaliko Beach Club, all-inclusive resort — banquet manager first, then Director of Operations
• About five to six years running departments, staff, revenue and guest experience
• Returned to Gatineau when the country's situation forced it

III — Care, then code (Gatineau)

• Nursing studies, then licence as a nurse assistant during COVID
• Five years of frontline care in long-term care, PCI champion
• Coding again for fun and on contract — with AI agents since day one

Direction & decomposition

• Parallel agent crews — one agent per subsystem (engine, audio, graphics, tooling), each with a bounded scope and a written contract
• Task decomposition — a milestone becomes 5–20 atomic tasks an agent cannot misread
• Ownership boundaries — file-level ownership so two agents never write the same module
• Model routing — the cheap model for grunt edits, the strong model for architecture and debugging
• Fresh-agent loops — restart context instead of letting a confused agent keep digging

Delivery contract

• Prompt 1 — define: the agent returns exact anchors and the runnable patch script, not prose
• Prompt 2 — ship: apply, build, run the gate, release
• Prompt 3 — verdict: accept, or roll back under protocol. There is no fourth prompt
• Atomic anchor injection — a 20-site change pre-planned as exact old/new string pairs and applied in one run: no drift, no half-applied state
• Escalation rules — agents stop and ask instead of guessing; destructive actions require a written order

Harness & context engineering

• Operating agent harnesses daily: DeepSeek Harness (DSH), Claude and Gemini agent wrappers, subagent fan-out, workflow orchestration scripts
• Persistent project memory — AGENTS.md rule files, handoff documents, size-history ledgers, commit reports that survive between sessions
• Context budget management — what an agent may read, when to compact, when to fork to a fresh context
• Prompt-as-code — reusable instruction files and patch programs, not one-off chat
• Cost discipline — tokens priced as the owner's money, not as free compute

Verification & trust

• Adversarial review — a second agent (or a fresh one) attacks what the first one produced before I accept it
• Claim-checking — an agent's "it works" is worthless until a machine check proves it
• Canary verification shields I designed: byte-truth CHR comparison, memory-isolation proof, register-write audits, ROM-size gates
• Rollback protocol authorship — written, human-gated recovery paths for anything destructive
• Live-session protection — agent rules that forbid killing or corrupting a running build

First three weeks — my own command box

• Built my own command box on curl to talk to ChatGPT — all in C
• Voice in, voice out: speech-to-text so I could talk to it, and a text-to-speech reader so it could answer me out loud
• Then Gemini and AI Studio, then DeepSeek, and now the agent CLIs

Now — fleets, not conversations

• I wrote my own software to manage unbounded numbers of agents safely — rules, contracts, verification gates, live-session kill-switches
• Agents do the typing; I own the architecture, the review and the release decision
• This website: free to build, and shipped in under an hour — deck, photo, English and French versions, live public link

Hardware-level engineering

• MMC3 mapper banking, bank-switch architecture, fixed-bank budget planning
• PPU control — NMI logic, scroll zones, palette updates, HBlank raster splits with zero visible seams
• Sprite systems — metasprites, OAM DMA, drift-free flip math, 12-sprite metatiles
• APU audio — custom sound engine, note tuning, rests, frequency logic, DMC sample pipeline, volume-trim macros
• Memory-map design — zero page, RAM relocation, code paging, XRAM buffers

Optimisation discipline

• Cycle-exact routines and cycle counting on a 1.79 MHz CPU
• Byte shaving to fit hard ceilings (a boot routine packed into 199 of 200 available bytes)
• Hidden code streams packed into unused graphics tiles and decoded at boot
• Debugging on emulator and real NES hardware
• Custom asset compilers: WAV→DMC, image→CHR, tile maps, metatile dictionaries

Relational (MySQL / SQL)

• Schema design and normalisation for internal business platforms
• Query writing and tuning — joins, filtering strategy, avoiding needless full scans
• Indexing — key selection on lookup and sort columns, composite keys, keeping write cost sane
• Data cleanup and migration scripts — deduplication, consistency passes, safe bulk updates
• Backend logic on top: PHP + MySQL internal platforms (co-founded AGF Web, 2012–2013)

Data structure & packed-format optimisation

• Structure-of-Arrays layouts — parallel lookup tables instead of row-major records
• Dictionary compression — 2×2 metatile dictionaries cut stage data by 60% (5,592 bytes saved) with 0 decode mismatches
• RLE and matrix transpose compression tools for tile data
• Deduplication of identical segments across a 500 KB asset set
• Compact binary formats for streaming code and audio chunks
• Ledger tracking — CSV/markdown size-history per commit (bank, ROM and sample utilisation)

Build & release

• Version-controlled development with strict line-ending and binary policies
• One-command reproducible builds (assembler → linker → ROM → verification)
• Automated release ritual with version bumping and artefact archiving
• Hard release gates: exact ROM size, correct mapper config, no stale segments

Quality engineering

• Designed a canary harness: byte-level asset comparison, memory-isolation proof, register-write audit, dead-code detection
• Static audits that ban unsafe patterns before they reach the ROM
• Test on emulator and hardware — the emulator passes first, the console decides
• Documentation as infrastructure: memory maps, routine inventories, handoff docs

Engine

• Custom collision, animation and input systems; dynamic macros
• Multiple fighters in isolated modules with independent memory planes
• Raster-split backgrounds, zero visible seams
• Song streaming into RAM; engine relocated out of ROM into console RAM

Measured results

• 5,592 bytes (60%) stage-data reduction — 0 decode mismatches
• 199 / 200 bytes — boot routine packed into unused CHR tiles
• 157 routines of sound engine moved to and executed from RAM
• 262,160-byte ROM ceiling enforced by an automated gate
• Every CHR chunk byte-verified against the built ROM on each release

Game I — Huns (2025, finished)

• Second complete NES game: four levels, open-world update, full playthrough
• Boss encounters — an electric boss with homing missiles, and a thunder boss
• Village puzzle sequence, X-ray visual effect, its own sound work
• Shipped after a long lag-frame hunt; the cartridge lands at exactly 262,160 bytes

Game II — C Fight (on the bench right now)

• The fighting game described on this page: four stages, two fighters, own engine and audio
• Actively in development — engine work in progress today
• Cartridge at 524,304 bytes, every asset byte-verified against the built ROM before release

University

• Bachelor of Science in Nursing — Université du Québec en Outaouais (UQO), 2021 → present
  Theory practically complete (pediatrics, perinatality, medicine-surgery passed); critical care and 1–2 final units remaining.
• Training in Operations & Logistics Engineering — Génie des opérations et logistique, not completed: C programming, electronics (circuit wiring, microchip programming, servo control) and CNC work with G-code. École de technologie supérieure (ÉTS), Montréal, 2010–2011
  Systems, process and logistics foundations behind the optimisation mindset.

College & diploma

• Long-Term Care Support (DEP) — École Vision Avenir, Gatineau, 2020
• Natural Sciences — Cégep de l'Outaouais, Gatineau, 2005–2009

Self-directed (continuous)

• 6502 assembly, NES hardware architecture, cc65 toolchain
• AI agent harness operation, prompt and context engineering
• Compression algorithms and data layout optimisation

Open to

• Systems / low-level programming (assembly, C, embedded)
• AI engineering roles — agent orchestration, tooling, evaluation
• Data and backend work — SQL, optimisation, pipelines
• Tooling, QA automation, technical documentation, localization
• Retro / game development contracts

Proof available

• Playable ROM, engine source, build and verification scripts
• Agent workflow documentation and project reports
• References available upon request
• French version of this document on request