Skip to content

Content Development Tasks for Innovation Studio

This document lists the tasks required to build out the curriculum content for the Innovation Studio based on the program plan, repository stubs, and README structure. Each section below corresponds to a part of the training that needs detailed instructional material, quizzes, and assignments.

During content creation, draft all PDF assets in Markdown format first. Once the content is finalized, generate the PDFs from the completed Markdown files. Create all diagrams using Mermaid markup within the Markdown. Export diagrams as images only for the finalized PDFs if necessary.

Orientation

  • Develop orientation_slides.md to cover program overview, FLSA compliance (with Primary Beneficiary Test), workflow tools (Slack, GitLab, Jira), and code of conduct expectations.

  • Create an orientation_lesson.md in a new common_assets/orientation folder summarizing orientation topics for TalentLMS import. Include:

  • Overview of the 12-week structure

  • Summary of each major tool used
  • Highlight of legal responsibilities and rights
  • Link to the full Code of Conduct

  • Produce a short quiz (orientation_quiz.json) testing:

  • What makes an unpaid internship legal (Primary Beneficiary Test)

  • Expectations around remote work
  • Code of conduct scenarios (e.g., handling harassment, professionalism)
  • Tool usage norms (e.g., Slack etiquette, when to use threads)

  • Draft an internship agreement template for interns to sign during onboarding:

  • Include start/end dates

  • Acknowledgment of unpaid status
  • Tie to academic program
  • Confidentiality clause
  • No guarantee of employment
  • Remote work address and expectations

Module M01 – Software Development Basics

  1. Lesson 02 – Python Basics (M01_Software_Development/lessons/02_python_basics.md)
  2. Write step‑by‑step explanations of Python syntax, variables, loops, functions, and script execution.
  3. Include sample code snippets and a short screencast video (media/01_python_video.mp4).
  4. Add at least 5 practice exercises (e.g., FizzBuzz, string reversal, prime checker) with expected input/output.
  5. Provide solutions in solutions/02_python_basics_solutions.md.
  6. Include a brief intro to using Git (git init, git commit) for tracking their work.
  7. Add quick reference sheet as media/cheatsheet_python_basics.md.
  8. Lesson 03 – SQL Foundations (M01_Software_Development/lessons/03_sql_foundations.md)
  9. Explain SELECT, INSERT, UPDATE, DELETE operations with practice tables.
  10. Create a database schema diagram in Mermaid (see media/02_sql_schema.mmd).
  11. Provide SQL examples tied to a sample dataset (e.g., northwind-lite.sql).
  12. Document how to install and use SQLite or PostgreSQL locally.
  13. Add structured practice exercises (e.g., "List all customers from Germany") and solution file solutions/03_sql_foundations_solutions.md.
  14. Lesson 04 – OOP and Algorithms (M01_Software_Development/lessons/04_oop_and_algorithms.md)
  15. Introduce classes, objects, inheritance, and object initialization in Python.
  16. Cover at minimum: Bubble Sort, Insertion Sort, Merge Sort, Linear Search, Binary Search.
  17. Add coding tasks: implement a Student class, a Dog class, and at least one algorithm.
  18. Include real-world analogies (e.g., inheritance = recipe variations).
  19. Add code examples, diagrams (e.g., class relationships in Mermaid), and solutions/04_oop_and_algorithms_solutions.md.
  20. Assignments
  21. Flesh out assignments/crud_project_instructions.md with:
    • Requirements to build a CLI CRUD app using Python and SQLite/PostgreSQL
    • Git commit and branch usage expectations
    • Sample project ideas (e.g., Task Tracker, Bird Log)
  22. Provide a starter project zip file or GitHub template link in the instructions.
  23. Create assignments/requirements_spec_template.md with sections for scope, functional requirements, user stories, and acceptance criteria.
  24. Add assignments/crud_project_rubric.md with scoring breakdown for functionality, clarity, modularity, and Git usage.
  25. Quizzes
  26. Create question banks:
    • quizzes/01_python_quiz.json: Covers variables, loops, functions, syntax
    • quizzes/02_sql_quiz.json: Covers query writing and interpreting output
    • quizzes/03_oop_algorithms_quiz.json: Covers class structure, object instantiation, sorting algorithm trade-offs, and Big O basics

  27. Optional Additions

  28. assignments/code_style_guide.md: Expectations for PEP8 compliance and docstrings

  29. assignments/github_walkthrough.md: Simple instructions for setting up and pushing to a GitHub repo

Module M02 – AI-Assisted Developer

  1. Lesson 01 – Intro to LLMs (M02_AI_Assisted_Developer/lessons/01_intro_to_llms.md)

  2. Overview of large language models, capabilities, and limitations.

  3. Provide demonstration video media/01_llm_demo.mp4.

  4. Break down key concepts such as:

    • Transformer architecture (encoder/decoder, self-attention)
    • Tokenization and word embeddings
    • Differences between pretraining and fine-tuning
    • Include a visual explainer diagram using Mermaid (media/transformer_architecture.mmd)
    • Add section on why LLMs are important for developers (e.g., coding assistants, content generation)

  5. Lesson 02 – Prompt Engineering (M02_AI_Assisted_Developer/lessons/02_prompt_engineering.md)

  6. Teach prompt structures (persona, context, examples) with practical exercises.

  7. Supply sample prompt reference sheet media/02_prompt_examples.md.

  8. Include walkthroughs of:

    • Zero-shot, few-shot, and chain-of-thought prompting
    • Prompt iteration: improving outputs through edits
    • Common failure modes and how to fix them

    • Add exercises:

    • Iteratively rewrite a prompt to improve accuracy or tone

    • Translate vague natural language into a well-structured command
    • Save examples in solutions/02_prompt_exercises_solutions.md

  9. Lesson 03 – Using the OpenAI API (M02_AI_Assisted_Developer/lessons/03_using_openai_api.md)

  10. Show how to authenticate and send requests, then parse responses in Python.

  11. Include examples using:

    • openai.ChatCompletion.create() (chat-style interactions)
    • openai.Completion.create() (text completions)
    • openai.Audio.transcribe() (Whisper for transcription)

    • Add setup instructions:

    • Create .env file and set OPENAI_API_KEY

    • Install dependencies (openai, dotenv)
    • Include reusable helper functions for token counting, retries, and formatting

  12. Lesson 04 – Understanding response_format={'type': 'json_object'} in LLM APIs (M02_AI_Assisted_Developer/lessons/04_response_format_json_object.md)

  13. Clarify how the response_format parameter enforces a single top-level JSON object.

  14. Show techniques for retrieving arrays: omit the parameter or wrap lists inside an object key.

  15. Provide sample code snippets illustrating both approaches.

  16. Lesson 05 – Using ChatGPT Codex for Development (M02_AI_Assisted_Developer/lessons/05_chatgpt_codex.md)

  17. Highlight Codex strengths for prototyping, documentation, and code interpretation while noting limits like security and context gaps.

  18. Compare gpt-4 and gpt-3.5-turbo to select appropriate models for a task.

  19. Demonstrate integrating Codex into a pull request workflow from prompt to merge, with follow-up exercises using prompt/API test harnesses.

  20. Lesson 06 – Best Practices for Using Codex Actions in Parallel (M02_AI_Assisted_Developer/lessons/06_codex_parallel_actions.md)

  21. Explain coordination strategies for simultaneous Codex workflows and risks of unplanned parallel actions.

  22. Emphasize atomic commits, scope boundaries, and version-control discipline to avoid merge conflicts.

  23. Recommend tools and CI integrations for conflict detection and resolution.

  24. Lesson 07 – Iterating on Web Page Code with ChatGPT (M02_AI_Assisted_Developer/lessons/07_iterating_web_page_code.md)

  25. Inspect existing web pages, copy source HTML, and identify accessibility or layout issues.

  26. Use ChatGPT to generate revised markup through iterative prompts and local testing.

  27. Integrate finalized changes into the project with a pull request.

  28. Lesson 08 – Codex Code Quality Scans and Test Generation (M02_AI_Assisted_Developer/lessons/08_codex_code_quality.md)

  29. Leverage Codex with tools like radon to flag high cyclomatic complexity and SOLID violations.

  30. Detect duplicated logic and prompt refactoring suggestions.

  31. Generate unit tests and measure coverage to safeguard refactored code.

  32. Lesson 09 – Case Study: Iterative Design of a Custom Assessment Form (M02_AI_Assisted_Developer/lessons/09_gemini_canvas_case_study.md)

  33. Follow Gemini Canvas iterations that enable tri-state switches and refine visuals and spacing.

  34. Adjust layout for responsive two-column assessments and add calls to action.

  35. Deliver a self-contained form with no external dependencies.

  36. Lesson 10 – Gemini Canvas UI Design (M02_AI_Assisted_Developer/lessons/10_gemini_canvas_ui_design.md)

    • Provide step-by-step UI design guidance using Gemini Canvas.
    • Reference media/gemini_canvas_ui_screenshot.svg and media/gemini_canvas_ui_flow.mmd for visuals.
    • Develop supporting materials: assignments/gemini_canvas_ui_mockup.md and quizzes/10_gemini_canvas_ui_quiz.json.

  37. Lesson 11 – n8n Workflow Automation (M02_AI_Assisted_Developer/lessons/11_n8n_workflow_automation.md)

    • Install n8n locally or via Docker and explore the workflow editor.
    • Differentiate trigger and regular nodes while building a Webhook → HTTP → Set → Slack flow.
    • Share tips on expression syntax, credential management, and chaining advanced automations.

  38. Assignments

    • Expand assignments/ai_refactor_exercise.md:

    • Interns must document their prompt attempts and results (what worked/didn’t)

    • Include at least one example using GPT to comment or optimize legacy code from M01
    • Optional: use LLMs to generate docstrings or write unit tests

    • Add second assignment: assignments/ai_code_gen_task.md

    • Interns write a structured prompt to generate a simple CLI utility (e.g., a to-do list or calculator)

    • Evaluate clarity of prompt, completeness of output, and debugging process

  39. Quizzes

    • Populate quizzes/01_prompting_basics.json with at least 10 questions covering:

    • Prompting techniques: zero-shot, few-shot, CoT

    • API usage and rate limits
    • Structure of API requests (roles: user/system/assistant)
    • Interpreting and troubleshooting prompt behavior

Module M03 – Agile and QA

  1. Lesson 01 – Agile Kanban (M03_Agile_QA/lessons/01_agile_kanban.md)

  2. Cover Agile principles and Kanban workflow with WIP limits, illustrating the process with Mermaid flow diagrams.

  3. Explain the four core principles of Kanban and the six core practices:

    • Visualize the workflow
    • Limit work-in-progress (WIP)
    • Manage flow
    • Make process policies explicit
    • Implement feedback loops
    • Improve collaboratively
    • Include a before/after scenario showing how Kanban reduces chaos compared to an unmanaged task list.
    • Provide instructions on setting up a team-managed Jira Kanban board, with sample workflow: To Do → In Progress → In Review → Done.
    • Add a Mermaid diagram to represent a sample board: media/kanban_flow_example.mmd.

  4. Lesson 02 – Bug Reporting (M03_Agile_QA/lessons/02_bug_reporting.md)

  5. Teach how to write effective bug reports using a clear format: Title, Environment, Steps to Reproduce, Expected Result, Actual Result, Visual Evidence, Severity.

  6. Provide examples of both poorly written and well-written bug reports.
  7. Include annotated screenshots and/or a demo video showing how to reproduce and document a real bug.

  8. Add common_assets/templates/bug_report_template.md interns can clone and use.

  9. Lesson 05 – Cyclomatic Complexity (M03_Agile_QA/lessons/05_cyclomatic_complexity.md)

  10. Define cyclomatic complexity and show how to calculate it for Python functions.

  11. Explain why high complexity leads to more required unit tests.

  12. Provide a code example with branching and a small Mermaid flowchart.

  13. Assignments

  14. Complete assignments/peer_review_checklist.md with:

    • Required review categories: readability, logic, spec compliance, security, testing
    • Reviewer comment section and approval checkbox list

    • Complete assignments/unit_test_writeup.md, where interns:

    • Write and document at least one positive-path test and one edge-case test

    • Include code snippets and test output logs or screenshots

    • Add new assignment: assignments/bug_hunt_exercise.md

    • Provide access to a buggy CLI app or pre-seeded GitHub repo

    • Instruct interns to find and document at least two issues using the provided bug report template
    • Require submission of report markdown files and supporting screenshots

  15. Quizzes

  16. Add questions to quizzes/01_qa_basics.json covering:

    • Software Testing Life Cycle (STLC) phases
    • Bug report anatomy
    • Test case design basics (positive/negative paths, edge cases)
    • Code review etiquette and common reviewer blind spots

    • Include scenario-based items:

    • "Which part of this bug report is unclear or missing?"

    • "Which issue should be prioritized based on severity and impact?"

Module M04 – From Concept to Market

  1. Lesson 01 – MVP Definition (M04_From_Concept_To_Market/lessons/01_mvp_definition.md)

  2. Explain how to identify user pain points and distill them into Jobs-to-Be-Done (JTBD).

  3. Define what makes a true MVP (minimum testable/valuable product).
  4. Walk through scope control techniques: feature slicing, prioritization matrices, and must-have vs. nice-to-have.
  5. Include a simple worksheet or template for MVP planning (media/mvp_scoping_canvas.md).

  6. Add a real example (e.g., from past intern projects) showing how a vague idea became a scoped MVP.

  7. Lesson 02 – Go‑to‑Market Strategy (M04_From_Concept_To_Market/lessons/02_gtm_strategy.md)

  8. Introduce the basics of:

    • Market segmentation and persona alignment
    • Positioning (value prop, messaging)
    • User acquisition channels (e.g., product-led growth, referrals, SEO)
    • Show how technical decisions (e.g., CLI vs. Web) affect GTM.
    • Include visual examples (positioning map, basic funnel diagram).
    • Add media/gtm_strategy_framework.mmd diagram with steps: Audience → Message → Channel → Outcome.

  9. Assignments

  10. Fill in assignments/capstone_guide.md with:

    • Team formation rules
    • Instructions for defining JTBD
    • MVP scoping checklist
    • Timeline and expectations for weekly demos
    • Demo Day format and presentation checklist

    • Update assignments/business_case_template.md:

    • Problem statement

    • Target user and JTBD
    • Proposed solution and MVP scope
    • Expected impact or value
    • (Optional) lightweight financial model or cost/benefit rationale
    • Add new worksheet: assignments/jtbd_mapping_canvas.md with prompts to extract user goals and map them to product features.

  11. Quizzes

  12. Write quizzes/01_gtm_quiz.json with questions covering:

    • JTBD vs. feature list
    • Definition and characteristics of an MVP
    • Basics of segmentation and positioning
    • Trade-offs between technical design and acquisition strategy
    • Include a scenario-based question: "You’ve built a prototype that solves X—what would you validate first before building more?"

Common Assets and Engagement

  • Design badge graphics in common_assets/badge_icons/ for each module and finalize certificate_template.md for program completion.
  • Draft Slack prompts for daily check‑ins and create a style guide for mentors on how to provide feedback in merge requests. See common_assets/mentor_resources/ for both documents.