Immersive, practitioner‑focused programs for modern software teams
While many teams struggle with disjointed AI approaches, your developers will master the complete AI application lifecycle—from LLM fundamentals to production deployment and security.
Why learn AI‑Driven Development now? Organizations adopting AI‑first development practices are seeing significant productivity gains and faster time‑to‑market. The gap between AI‑fluent and AI‑struggling teams continues to widen.
Choose the track that fits your team's transition to AI‑native development:
Fast‑paced, high‑impact immersion for teams ready to implement AI workflows immediately. Go from concepts to deployment in just 5 days.
Perfect for: Teams with immediate AI implementation needs
Comprehensive, deep‑dive program building lasting expertise with advanced techniques, evaluation methodologies, and real‑world applications.
Perfect for: Organizations investing in long‑term AI capabilities
Both courses deliver practical, immediately applicable skills—focusing on tools and techniques your team can implement directly into their workflow.
Courses available for booking throughout the year
| Detail | Info |
|---|---|
| Format | 1 week, full‑time (09:00 – 17:00 daily, 60‑min lunch) |
| Audience | Intermediate → senior developers (Python & git fluent) |
| Prerequisites | Standard laptop with internet access. Development environment will be set up on day one with guided assistance. |
| Objectives | • Master LLM foundations, embeddings, vector DBs, RAG and evaluation • Build & evaluate a LangChain/LlamaIndex retrieval‑QA system • Apply IDE copilots (Cursor, GitHub Copilot, Cody) for refactor, test‑gen & docs • Ship a guarded, containerised LLM micro‑service |
| Tools & Stack | Python · Jupyter · FAISS/Chroma · OpenAI/LLM · LangChain · LlamaIndex · RAGAS · Cursor · Copilot · Docker |
Each day combines theoretical foundations in the morning with extensive hands-on application in the afternoon. Participants will progressively build components of a complete, production-ready AI system throughout the week.
| Day | Morning (Theory + Demos) | Afternoon (Hands‑on Labs) | Key Outcomes |
|---|---|---|---|
| 1 — LLM Core |
• Transformer architecture fundamentals
• Context window optimization
• Parameter tuning (temperature/top‑p)
• Effective prompt patterns
• Cost & latency considerations
|
• API integration with OpenAI/Claude
• Zero/few‑shot prompting techniques
• Structured JSON output extraction
• Building a basic prompt template system
• Error handling and retry strategies
|
Working text-to-text and text-to-structured-data application connecting to commercial or open-source LLMs |
| 2 — Embeddings & Vectors |
• Embedding model comparisons
• Semantic vs. lexical search
• Similarity metrics (cosine/dot/Euclidean)
• Vector DB selection criteria
• Performance optimization techniques
|
• Text chunking and preprocessing
• FAISS vector index creation
• Building a semantic search CLI tool
• Metadata filtering implementation
• Query optimization strategies
|
Functioning semantic search application over custom document collection with command-line interface |
| 3 — RAG & Evaluation |
• RAG architecture patterns
• LangChain vs. LlamaIndex comparison
• Evaluation metrics and benchmarks
• RAGAS implementation strategies
• Advanced retrieval techniques
|
• Building a retrieval-QA chain
• Context window management
• Result evaluation with RAGAS
• Identifying and fixing hallucinations
• Performance tuning and optimization
|
Complete RAG pipeline with evaluation dashboard, ready for domain-specific documents |
| 4 — AI‑Driven Dev I |
• IDE copilots architecture comparison
• Effective prompting for code generation
• AI refactoring best practices
• Test generation strategies
• Code review automation
|
• Paired programming with AI assistants
• Feature implementation sprints
• Automated test generation and validation
• Bug identification and fixing
• Performance optimization
|
Enhanced feature set for the RAG application with comprehensive test suite and optimized performance |
| 5 — AI‑Driven Dev II |
• Prompt-driven specification writing
• Technical documentation automation
• LLM guardrails implementation
• Monitoring and observability
• Deployment best practices
|
• Auto-generating documentation
• Creating release notes
• Containerizing the application
• Implementing security measures
• Red-team testing and jailbreak prevention
|
Production-ready, containerized RAG micro-service with documentation, monitoring, and security guardrails |
"After just one week, our team implemented a RAG system for our internal documentation that reduced support requests by 30%. The ROI was immediate."
— CTO, Mid‑size FinTech Company
| Detail | Info |
|---|---|
| Format | 12 weeks, 2 ×2 h live sessions per week (e.g., Tue & Thu evenings) |
| Audience | Working devs seeking deep, practice‑oriented AI skills |
| Prerequisites | Same as Bootcamp. Prior programming experience recommended but not strictly required. |
| Goals | • End‑to‑end proficiency with LLM pipelines, evaluation & secure deployment • ≥ 12 h focused on AI productivity (copilots, spec/ticket/doc automation) • Capstone project: production‑ready, monitored LLM app |
| Week | Session A (Tue) | Session B (Thu) |
|---|---|---|
| 1 | LLM Foundations • Transformer anatomy (attention, tokens, logits) • temp / top‑p / max‑tokens • model families (GPT‑4o, Claude 3, Llama 3) | Prompt Basics • zero / few / chain‑of‑thought • role & system messages • JSON / schema‑forced output • live: iterate 3 prompts |
| 2 | Code Gen 101 • Cursor & Copilot setup • inline completions vs chat • refactor, unit‑tests, regex prompts | AI Debug Loop • trace‑explain‑fix pattern • Copilot‑test‑fail‑refine lab • linters & type‑check with AI |
| 3 | Embeddings Deep Dive • cosine / dot / Euclid • text‑embedding‑3‑small vs BGE‑base • chunk sizing & overlap | Vector DB Hands‑on • FAISS vs Chroma vs Weaviate • metadata filters, HNSW params • index build + k‑NN query |
| 4 | Manual RAG Pipeline • retrieve → augment → generate • citation‑rich prompt template | RAG Evaluation Intro • precision / recall vs faithfulness • RAGAS first score run • diagnose low‑score causes |
| 5 | LangChain Quick‑Start • PromptTemplate, LLMChain, Memory • VectorStoreRetriever, RetrievalQA | LlamaIndex Quick‑Start • Document loaders • GPTVectorIndex, TreeIndex • query engine playground |
| 6 | Hybrid & Iterative Search • BM25 + vectors • query‑rewrite chain • Cross‑Encoder rerankers | RAG Tune‑Up Lab • swap embed model • vary top‑k & rerank • RAGAS before/after diff |
| 7 | IDE Copilots Deep‑Dive • Cursor vs Windsurf vs Copilot vs Cline vs Claude-Code... • AI‑assisted large‑refactor workflow • security‑aware prompts | Test & CI Automation • AI‑generated unit/property tests • GH Actions: RAGAS & pylint • fail‑fast gates |
| 8 | Spec & Ticket Generation • RFC/ADR via prompt • Jira/Linear task drafts • acceptance‑criteria checklist | Docs & Release Notes • README autowrite • OpenAPI + Swagger from prompt • semantic‑changelog gen |
| 9 | LLMOps Basics • prompt‑versioning, eval sets • LangSmith / Traceloop logging • latency + cost dashboards | Security & Guardrails • prompt‑injection patterns • validator → LLM → output filter • red‑team mini‑drill |
| 10 | Capstone Kick‑Off • idea pitch & scope • architecture sketch (diagram prompt) • dataset & success metrics | Prototype Sprint • MVP RAG/agent chain running • log + eval harness wired |
| 11 | Testing & Hardening • nightly RAGAS • load / stress test • fallback model & cache | Finalize & Deploy • Docker + env secrets • readiness / liveness probes • cost guardrails |
| 12 | Capstone Demos • 10‑min live demo each team • peer review & Q &A | Retrospective & Next Steps • lightning lessons‑learned • advanced reading list • certificates issued |
The Professional Track culminates in a comprehensive capstone project that spans the final 3 weeks of the course. Working individually or in small teams, participants build a production-ready AI application that solves a real business problem.
The capstone serves as both a practical application of all course concepts and a portfolio piece demonstrating your team's new capabilities. Projects are guided from initial concept to final deployment with regular feedback sessions and technical reviews.
"Our engineers are now AI force multipliers. They're not just using AI—they're building systems that transform how our entire company operates."
— VP Engineering, Enterprise Software Company
The curriculum can be tailored to your team's specific needs:
ROI Focus: Teams implementing these techniques typically see productivity increases in code generation, testing, and documentation tasks. One client reduced their feature delivery time by 40% within three months of training.
Equip your developers with the skills to build effective, production-ready AI applications.