Areas of Exploration
High-value opportunities to integrate AI into software development workflows. Each area describes what becomes possible — explore at least two with your cohort during AI Week.
Thank you to Rob Ayers for curating these areas of exploration.
Codebase Understanding & Navigation
Rapidly orient to any codebase by analyzing structure, explaining unfamiliar components, and identifying the patterns in use. Generate architecture diagrams and specifications to surface what exists, how modules interconnect, and where responsibilities are divided. This gives the team a shared map before making changes.
Code Development
Read a codebase, plan a sequence of actions, and execute changes across multiple files, operating at the project level rather than suggesting the next line. Build new features, perform refactors, and resolve bugs from a description or error message. Break problems into steps, maintain context across files and goals, and treat AI as a true collaborator that iterates toward a working result.
Hardware-Adjacent & Embedded Workflows
Support embedded and hardware-adjacent work including register map generation, datasheet parsing, firmware authoring and review, and communication protocol handling across CAN, SPI, I2C, and UART. Assist with cross-compilation scripts and interpret debugging output from serial monitors or JTAG sessions. This remains one of the most underexplored areas for AI tooling and one of the richest for experimentation.
Infrastructure Development & Testing
Create and modify CI/CD pipelines and infrastructure-as-code configurations. When tests fail, read the errors, fix the underlying code, and re-run the suite until everything passes. Monitor pipelines on GitHub and GitLab and commit fixes automatically. Generate meaningful unit, integration, and edge-case tests. Simulate failures, mock dependencies, and build harnesses for systems that are difficult to reproduce, such as hardware environments or constrained network conditions.
Documentation
Produce comprehensive documentation for major services, covering architecture, data flows, API routes, database schemas, external dependencies, key files, common failure modes, and operational procedures. Go beyond surface-level descriptions to capture the nuances that matter most to the teams maintaining and extending these systems.
Code Review & Quality
Use the GitHub CLI to create pull requests, review code, and check workflow runs without leaving the terminal. Serve as a sounding board for evaluating solution approaches, applying coding principles, and enforcing standards derived from the existing codebase. This ensures consistency across contributors and over time.
Git & Version Control Workflows
Eliminate the need to memorize commands for Git, Kubernetes, or other CLI tools. Describe the desired outcome in plain language and let AI invoke the right commands with correct syntax, using tools like the GitHub CLI natively to execute branching, merging, rebasing, and release workflows without friction.
Debugging & Incident Investigation
Provide full failure context including logs, stack traces, error messages, configuration files, and relevant code, and let AI reason across all of it at once. Trace bugs across system layers, correlate failures across services, and surface likely root causes ranked by supporting evidence. For embedded work, interpret serial output, analyze memory dumps, and reason about timing or protocol failures that are difficult to reproduce in isolation.
Repetitive & Tedious Tasks
Automate low-context, high-frequency work such as running tests, executing lint checks, generating test data, and making test API calls. Also handle fixing lint issues, resolving merge conflicts, and drafting release notes. This frees engineers to focus on work that requires deeper judgment.
System Integration & API Orchestration
Rapidly connect disparate services, translate between APIs, generate integration layers, and prototype cross-system workflows. Reduce the time and effort required to explore new service compositions and lower the cost of validating integration approaches before committing to a full implementation.
Observability & Telemetry Analysis
Analyze logs, metrics, and distributed traces to identify patterns, anomalies, and root causes across complex systems. Suggest targeted improvements to instrumentation and monitoring coverage so that visibility keeps pace with system growth and change.
Security & Risk Analysis
Identify vulnerabilities, analyze third-party dependencies, and suggest secure coding practices aligned with the existing codebase. Evaluate potential threat scenarios across services and surface risk areas that might otherwise be overlooked during fast-moving development cycles.
Architecture & Planning
Assist with planning, implementation, debugging, and documentation generation across the full development lifecycle. For complex architectural decisions and multi-step implementations requiring extended reasoning, longer autonomous sessions with a more capable model handle the depth and continuity these problems demand.
Training References
Cursor