Frame the direction
Define the problem, audience, constraints, and success criteria. Pair a rough hand-drawn wireframe with visual references and a focused initial prompt.
AI methodology
Human direction.
Machine acceleration.
AI is integrated throughout my workflow—from research and rapid iterative prototyping to enterprise-grade, production-ready code. I combine design and coding, using AI surgically where it creates leverage while keeping product judgment, visual integrity, and final execution human-directed.
How I work
A hybrid workflow built for speed, precision, and working software.
After discovery and competitive analysis, I move fluidly between sketches, visual references, Figma, prompting, and source code. The goal is not maximum automation. It is a tighter loop between thinking, design, implementation, and production—with the right tool used at each handoff.
Current production workflow
From initial design intent to a live, maintainable system.
The exact stack changes by project, but the operating model stays consistent: establish intent, accelerate exploration, edit directly where precision matters, inspect the implementation, and test the final experience in context.
Generate the first pass
Use AI to translate the sketch and references into an initial HTML prototype, Figma direction, component, or structured content model.
Iterate by hand + prompt
Move between direct design edits and targeted prompting. Connect Figma to Codex, Claude, or Cursor through MCP so the model can inspect the actual frame.
Code and reconnect
Often I start in HTML, move one section into Figma for manual refinement, then have AI reread that frame and implement the latest visual decisions.
Inspect and finish
Review source code, responsive behavior, accessibility, failure states, visual integrity, and production feasibility before the work ships.
Prompt where it creates leverage.
AI is strongest at research synthesis, early exploration, scaffolding, transformations, controlled variations, and rapid functional prototyping. Those are the places where prompting meaningfully compresses time.
Edit directly where precision matters.
Even with annotated screenshots or MCP-linked frames, models can lose finish details or change unrelated sections while solving a micro-edit. Hand edits preserve hierarchy, consistency, and the bespoke quality of the experience.
Stay close to the source code.
I continuously inspect what the model produces. That lets me catch code bloat before it compounds and often debug faster than repeated LLM passes that overengineer both the original implementation and the attempted fix.
Connect design back to implementation.
I do not treat Figma and code as separate handoff stages. MCP lets the model inspect my latest frame directly, while direct browser and code review keeps the production result aligned with the design intent.
Technical judgment beyond the front end.
My Python background and earlier computational work in Scheme/Lisp and data structures allow me to advise on the systems behind the interface—not only its presentation. For this portfolio, for example, I use Markdown, JSON, JavaScript, HTML, and CSS to create dynamic, role-specific behavior on a static site without the cost or complexity of a connected database.
Primary environment: ChatGPT Codex, Claude, Figma with MCP, and Cursor as my IDE and coding assistant.
Independent audits: Gemini and Meta for content/design critique; Grok for additional code review.
Media production: CapCut, ElevenLabs, AudioOne, and supporting production tools for image, voice, audio, and video assets.
The framework behind the systems
From an AI-assisted workflow to software that understands context.
The workflow above uses human judgment to keep intent intact as work moves between tools. SMA extends that same concern into the product architecture itself: meaning is defined before a system decides what to render, recommend, or execute.
A framework I created for adaptive software.
SMA creates a structured meaning layer between raw signals and software behavior. Instead of sending context directly into execution, the system first defines who is involved, what they are trying to accomplish, what the situation requires, and which interaction constraints must remain intact.
Collect relevant context.
Identity, environment, state, intent, system events, constraints, and other inputs become structured signals.
Interpret before acting.
A semantic layer resolves priorities, relationships, confidence, temporal context, and what the current situation means.
Project governed behavior.
The shared meaning can drive adaptive interfaces, agent decisions, recommendations, and workflows within explicit constraints.
Define meaning once. Project it everywhere.
The same inspectable semantic contract can support interfaces, structured data, recommendations, agents, and automated workflows without allowing context to drift between them.
Design the reasoning surface.
Users need to understand what an agent knows, what it plans to do, where its confidence comes from, and when human approval is required—not merely see a chat box.
The operating principle