One week, live and remote. Your team goes from AI-assisted prompting to shipping real software: architecture that scales, security that survives an audit, data handled properly, and the testing and deployment work that separates a product from a demo. The same engineering discipline behind Fortune 500 AI work, taught so your people can do it themselves.
Your team is already using AI to write code. The demo works. Then it meets real users, real data, real load, and a compliance review, and the gap shows. This workshop closes that gap. It teaches the architecture and delivery judgment that turns AI-assisted output into software you can ship and support.
Ten modules, from tooling and mental models through architecture, data, security, and delivery.
LLM vs harness. Global vs project configuration. Skills as reusable functions. Plugins. Agent orchestration versus a single agent.
Turning ad-hoc prompting into a repeatable process. BMAD as a development methodology. Archon for deterministic workflows. Build your own versus adopt a framework.
Keeping API keys private. Tuning generative output to your voice and brand. Front-end quality with ShadCN and Pencil. Diagramming with Excalidraw and Mermaid. Docs with Docusaurus.
Why AI-assisted apps become slop. Two tiers (SMB and enterprise) and why picking the wrong one is the real mistake. Request/response, REST, client-server boundaries, deployment shapes.
When one backend breaks. Load balancing and scale sets. Session state and why statelessness pays off. Caching. What the cloud handles versus what you design.
What an LLM actually is: a token predictor, not a database. Context windows, and what a big one costs you. Why the same prompt gives different answers on different runs. Hallucination, grounding, local versus hosted, and where that slow async call belongs in your architecture.
When a JSON file is enough and when you need a real database. SQLite through full RDBMS, and where relational beats NoSQL. Web apps as the primary build, with Electron for native desktop on Mac, PC, and Linux.
JWTs, RBAC, multi-tenancy, secrets management, injection and input validation, audit logging. Data residency and GDPR, HIPAA, PCI-DSS, SOC 2. Prompt injection and never sending PHI to third-party models.
Why testing is the line between working software and slop. What unit, integration, and end-to-end tests each catch. Load and stress testing that proves the architecture holds.
The path from a laptop to production. Environments, Docker, CI/CD pipelines, secrets in deployment, monitoring. Then the writing: PRDs, runbooks, API docs, and docs as context for the model itself.
Every module and all five build phases. The same document your team gets.
Your team builds a support-ticket helpdesk application end to end. Each phase is chosen to exercise specific concepts from the curriculum. The LLM feature is added after a plain working app, so the team feels the upgrade rather than taking it on faith.
Data model for tickets, users, comments, and status. Start on SQLite, then the same schema on a full RDBMS. A REST API to create, read, update, and close tickets. Front end with ticket list, detail, and new-ticket form.
Login with JWTs. Three roles: end user files, agent resolves, admin configures. Multi-tenancy with one instance serving several client companies and tenant-isolated data. Secrets kept out of code.
Wrap the working web app in Electron. This is the "shorten the wire" moment: same code, but client and server collapse toward one process. Build native for Mac, PC, and Linux.
Auto-summarize a long ticket thread or draft a suggested agent reply. Handle it as a slow async call without freezing the UI. Never send another tenant's data or PII to the model.
Unit and integration tests on the API. A load test against the ticket endpoints that makes enterprise-tier theory real. Docker container plus a basic CI/CD pipeline. A short PRD up front, a runbook and user doc at the end.
Five days, delivered live and remote. No pre-recorded videos, no self-paced drift.
Your team builds a real application end to end. They write the code, not watch someone else write it.
Small enough that every participant gets direct attention when they get stuck.
A support-ticket helpdesk, built web-first and then converted to native desktop.
The teaching fee is the same either way. What differs is who provides the lab and model access for each participant.
Your organization supplies a development environment and Anthropic model access for each participant. You own setup and your team's readiness on day one.
A pre-configured, isolated cloud lab per participant with model access provisioned and capped, set up and torn down for you.
The rate steps down as you commit earlier or partner on a case study.
The full private-cohort rate. Up to 12 seats, one week.
Signed and scheduled more than 60 days out.
A written case study and permission to name your organization as a client.
Early-commit and launch-partner combined, or a repeat booking.
A 50% deposit secures the cohort. The deposit is non-refundable.
Full payment is due no later than two weeks before the start date. If it is not received, the course reschedules and that counts as one of the two free reschedules.
Two reschedules at no charge. The third and fourth each carry a 15% uplift on the total fee. A fifth request places the agreement in breach; it is canceled and the deposit retained.
These terms reflect the commitment required from both sides. A week of a senior instructor's time is reserved for your cohort, and the terms exist so that reservation holds.
Tell me about your team and your timeline. I'll tell you honestly whether this workshop is the right fit before either of us commits.
Start the Conversation