Beta - Productivity as Code
Course Description
Productivity as Code: Engineering best practices for knowledge work
Technologies Covered
About the Instructor
Giuseppe & Max
Giuseppe Battista is a senior solutions architect at Amazon Web Services with more than 12 years of industry experience. He's helped countless enterprise and startup customers build secure and scalabl...
View InstructorSign in required to enroll
Most companies reimburse for professional development
What you'll learn:
- Intro Module: Productivity as Code Foundations
- Exercise 0: Install Kiro And Clone The Course Repository
- Exercise 1: Inputs And Inbox Context
- Exercise 2: CRM Automation With MCP
- + 8 more modules
Course Curriculum (12 modules)
Intro Module: Productivity as Code Foundations
This opening module introduces Productivity as Code as a methodology for giving AI a real working environment. Students learn why blank AI chats lose value over time, how Markdown and Git create durable context, why steering files turn tribal knowledge into reusable guidance, and how MCP gives agents controlled access to tools. The module frames the course as "AI my way": AI workflows that fit the way individuals and teams actually work. Prerequisites: - No prior setup required for watching. - Helpful background: basic familiarity with files, folders, Markdown, Git, and AI chat tools. - Before starting the exercises, install Git, Kiro, Docker, Node.js/npm, Python, and `uv`.
Exercise 0: Install Kiro And Clone The Course Repository
Students prepare their local course environment. The video walks through downloading and installing Kiro, importing the course productivity repository into a personal GitHub account, cloning that repository into Kiro, and confirming that the folder structure and example steering files are ready for the hands-on exercises. Prerequisites: • A GitHub account. • Permission to create or import a private repository. • Internet access to download Kiro. • Basic familiarity with copying repository URLs.
Exercise 1: Inputs And Inbox Context
Students connect Kiro to Gmail through an MCP server and use email as the first input channel for a productivity workflow. The exercise shows how inbox context can become priorities, tasks, notes, CRM inputs, and repository updates while keeping write actions under human review. Prerequisites: - Kiro installed locally. - Node.js and npm. - A test Gmail account. - Google Cloud access to enable the Gmail API. - Read the book's security section before creating OAuth credentials.
Exercise 2: CRM Automation With MCP
Students connect Kiro to a local EspoCRM instance through MCP so customer signals can become structured CRM records. The exercise teaches tool-mediated workflow: the model reasons over context, but the MCP server performs controlled API actions against a business system. Prerequisites: - Docker and Docker Compose. - Kiro installed locally. - Node.js/npm for the EspoCRM MCP server. - Local EspoCRM running from the course resources. - An EspoCRM API user and API key with limited permissions. - Read the book's security section before creating or pasting API keys.
Exercise 3: Build A Local MCP Transcription Tool
Students build their own local MCP server with Kiro. The tool turns audio recordings into Markdown transcripts by uploading audio temporarily to S3, running Amazon Transcribe with speaker labels, and saving the result back into the productivity repository. Prerequisites: - Kiro installed locally. - Python and `uv`. - AWS account. - AWS CLI configured with a scoped profile. - S3 bucket or prefix for temporary transcription uploads. - Permission to use Amazon Transcribe.
Exercise 4: Build A Writing Style Guide
Students use Firecrawl to gather prior writing samples, store them locally, and ask Kiro to create a reusable personal writing-style steering file. The exercise shows that voice is context: once your writing style is captured as steering, future drafts can sound less generic and more like you. Prerequisites: - Kiro installed locally. - Firecrawl account and API key. - Node.js/npm for the Firecrawl MCP server. - Writing samples you are allowed to collect and reuse. - Read the book's security section before configuring the Firecrawl API key.
Exercise 5: Team Standards With Git Submodules
Students move from personal productivity to team productivity by consuming shared team standards through a Git submodule. The exercise shows how managers can publish reporting or meeting expectations as Markdown steering files without forcing every contributor into the same personal workflow. Prerequisites: - Git installed. - Kiro installed locally. - A productivity repository. - A team standards repository or a prepared sample equivalent. - Basic comfort with Git submodules.
Exercise 5.1: Updating Standards And Migrating Work
Students learn what happens when a team standard changes. Kiro checks for submodule updates, explains the changed standard, and helps migrate existing work into the new structure. The lesson is that shared standards should evolve without forcing contributors to manually decode Git submodule workflows. Prerequisites: - Completion of Exercise 5. - A productivity repository with the team standards submodule already configured. - Kiro installed locally. - Existing reports or notes that can be migrated safely.
Exercise 6: Scheduled Reports With GitHub Actions
Students run Kiro headlessly inside GitHub Actions to generate a recurring AgentCore opportunity report from repository context. The exercise shows how reports can become repeatable infrastructure: a scheduled workflow checks out the repo, runs Kiro CLI, applies steering files, writes the report, and commits the result. Prerequisites: - GitHub repository based on the productivity repo. - Kiro CLI. - Kiro API key or plan that supports headless execution. - GitHub Actions enabled. - Ability to create GitHub Actions secrets. - Read the book's security section before storing `KIRO_API_KEY`.
Exercise 7: Manager Rollups
Students see how a manager repository can consume agreed outputs from multiple contributor repositories and generate team-level summaries. The exercise focuses on transparency: manager rollups should reduce status-report burden, not become hidden surveillance. Prerequisites: - Familiarity with productivity repositories. - Git and Git submodules. - At least two contributor repositories or representative sample repositories. - Clear agreement on which files are team-shareable. - Kiro installed locally.
Exercise 8: Bottom-Up Improvements With Pull Requests
Students complete the team collaboration loop by proposing improvements back to the shared team standards repository. John notices that MBR content clutters the README, asks Kiro to update the reporting steering file, opens a pull request, and the manager merges it. Laura then receives the updated standard through the submodule and creates her MBR in the new structured reports path. Prerequisites: - Completion of Exercises 5 and 5.1. - A team standards repository. - A contributor productivity repository using the team standards as a submodule. - GitHub CLI `gh` or the equivalent tool/API for your Git platform. - Permission to open and merge pull requests in the relevant repositories.
Exercise 9: Agentic Interfaces With Simple Kirolets
Students operate a productivity repository from Telegram. A user sends a message from their phone, Simple Kirolets runs Kiro CLI headlessly against a repository, and the result comes back as either an answer, a branch, or a pull request. The exercise shows that the repository can become an agentic surface beyond the IDE. Prerequisites: - Simple Kirolets repository cloned locally. - Kiro CLI and API key. - Telegram bot token. - GitHub token with limited repository permissions. - Python and `uv`, or Docker for containerized execution. - A target repository for Simple Kirolets to operate on. - Read the book's security section before configuring tokens.