AI Tools

  ⤵️ Quick shortcut: Select the module you’re currently studying ⤵️

  Courses      Module 1     Module 2    

Module 1: AI Landscape for Software Development

1. Learning Objectives
   
   

   • Understand the new generation of AI tools focused on software development (code assistants, AI-based testing, AI-generated documentation, etc.).

   • Learn about key trends and concepts such as vibe coding and documentation-first workflow.

   • Identify main considerations regarding security, costs, and licensing of AI tools for development.

2. Key Topics
   
   

   • Current AI Ecosystem for coding:

     • Code assistants (Copilot, CodeWhisperer, Tabnine, Cursor, V0).

     • AI-driven testing tools (Meticulous, etc.).

     • IDE/local environment integrations vs. SaaS solutions.

   • Emerging Trends:

     • Documentation-first as a strategy to guide AI tools in code generation and documentation.

     • Vibe coding: definition and use cases.

   • Adoption Considerations:

     • Code and model security (handling private repositories, confidentiality).

     • Costs (cloud-based vs. on-premises vs. hybrid).

     • Ethics and accountability (use of generated code, snippet licenses).

3. Suggested Exercise
   
   

   • Create a mind map of all tools and concepts introduced (code assistants, automated testing, etc.), highlighting where they fit in a typical development pipeline.

Module 2: Advanded workflows

1. Learning Objectives
   
   

   • Explore in detail one of the most powerful and up-to-date code assistant tools.

   • Master prompt engineering techniques and configurations to maximize productivity.

   • Implement the documentation-first workflow

2. Key Topics
   
   

   • Code Assistant Tools:

     1. Junie

     2. Copilot

     3. WindSurf  

     4. Cursor

   • Modern Techniques:

     1. Prompt engineering for specific code generation (tests, refactors, documentation).

     2. Documentation-first workflow:

        • Writing documentation/contracts (e.g., interfaces, endpoints) before generating code.

        • Having AI keep documentation and implementation in sync.

     3. Vibe coding:

        • Emphasizing flow and co-creation with AI without strictly following guidelines.

        • Use cases for prototyping and exploring ideas.

     4. Main SWE Lancer

3. Suggested Exercise
   
   

   • Take an example project (e.g., a REST app in Node.js, Python, or Java) and:

     1. Start by creating documentation for a new feature (specifications, endpoints, data structures).

     2. Generate the base code with the help of one of these assistants.

     3. Iterate in vibe coding mode, adding improvements and interactive changes.

     4. Document how the AI refactors or updates the documentation automatically.

Module 3: Testing and Intelligent QA

1. Learning Objectives
   
   

   • Discover AI-assisted testing tools (Meticulous and others).

   • Learn to generate and maintain unit, integration, and end-to-end tests using code assistants.

   • Evaluate test quality and the reliability of recommendations.

2. Key Topics
   
   

   • Meticulous:

     • How it works (capturing user flows, replay, snapshot comparisons).

     • CI/CD integration and QA pipelines.

   • Automatic Test Generation:

     • Prompt engineering for obtaining the desired test coverage.

     • Guiding AI to follow internal conventions (naming, mock objects, setup/teardown).

   • Validation and Metrics:

     • Test coverage vs. relevance.

     • Including edge cases and security tests with AI support.

   • Best Practices:

     • Manually review generated tests to ensure validity and avoid false positives.

     • Develop policies for using auto-generated tests (aligned with team culture).

3. Suggested Exercise
   
   

   • In the same project from Module 2, generate multiple test levels (unit, integration).

   • Use Meticulous (or a similar tool) to capture application navigation and create e2e tests.

   • Analyze the results: how good are the generated tests? what manual improvements are needed?

Module 4: LLM Agents and Collaborative Workflows

1. Learning Objectives
   
   

   • Understand what “agents” based on LLMs are and how they can automate tasks in the development cycle.

   • Learn how to integrate these agents with repositories, issues, documentation, and CI/CD pipelines.

2. Key Topics
   
   

   • What Are Agents?

     • Examples: Auto-GPT, LangChain Agents, ChatGPT Plugins.

     • Capabilities and limitations (context size, reliability, dependency on external sources).

   • Practical Use Cases:

     • Automating PR creation for fixes or features.

     • Generating documentation and progress reports based on commits and issues.

     • Monitoring logs and suggesting security or performance patches.

   • Integration with Project Management Tools:

     • GitHub Issues, Jira, Trello.

     • Automated workflows for labeling, assigning, and updating status.

   • Best Practices:

     • Maintaining a consistent “context” so the agent doesn’t lose track of the project state.

     • Validation and approval policies for code suggested by an agent (human in the loop).

3. Suggested Exercise
   
   

   • Configure an agent (e.g., with LangChain or a similar platform) to monitor a repository.

   • Have the agent suggest small fixes or create code documentation based on recent commits.

   • Review and approve suggestions within the team, discussing how productive this approach can be.

Module 5: Continuous Integration and Delivery (CI/CD) with AI

1. Learning Objectives
   
   

   • Learn to embed AI tools (code assistants, automated testing, agents) in CI/CD pipelines.

   • Adopt strategies for quick deployment with continuous feedback.

2. Key Topics
   
   

   • CI Tool Integration:

     1. GitHub Actions, GitLab CI, Jenkins: setups for triggering generated tests or refactor suggestions.

     2. Auto validations of coverage and static analysis via AI.

   • Automating Pull Requests:

     1. Using AI to write PR descriptions (messages, change summaries).

     2. Auto-merge mechanisms when the auto-generated test suite passes.

   • Monitoring & Feedback:

     1. Automated alerts if a code assistant suggests risky changes (based on metrics).

     2. Measuring time saved and post-deployment quality.

   • Use Cases:

     1. Microservices with frequent updates.

     2. Large monorepos with multiple teams.

3. Suggested Exercise
   
   

   • Configure a pipeline in GitHub Actions or GitLab CI that:

     1. Runs static analysis.

     2. Invokes an AI tool to correct potential code smells or suggest refactors.

     3. Automatically generates or updates the project documentation.

Module 6: Evaluation, Metrics, and AI Tool Benchmarks

1. Learning Objectives
   
   

   • Learn about new “SWE benchmarks” to measure the quality of suggestions from LLMs and code assistants.

   • Design in-house experiments to compare different tools (Copilot vs. Cursor vs. Tabnine, etc.).

2. Key Topics
   
   

   • Key Metrics:

     1. Accuracy of proposed code (what percentage compiles or passes tests?).

     2. Estimated time savings (productivity).

     3. Adoption rate (how much of the final code originated from AI suggestions?).

   • Evaluation Frameworks:

     1. Tests using a “gold standard” repository.

     2. Qualitative and quantitative metrics (code style, readability).

   • Practical Comparisons:

     1. Real-world examples from companies or open-source projects measuring the efficiency of code assistants.

     2. How to interpret and communicate results to leadership.

3. Suggested Exercise
   
   

   • Define a small internal benchmark:

     1. Pick 2–3 code assistants.

     2. Measure how long each one takes to solve a set of coding “challenges” (functions or tasks).

     3. Collect data on quality (tests passed, minimal corrections required).

     4. Produce a comparative report for sharing within the organization.

Module 7: Future Trends and Long-Term Adoption Strategy

1. Learning Objectives
   
   

   • Analyze emerging trends in AI for development (new open-source models, vibe coding vs. stricter workflows).

   • Prepare a plan for continuous adoption and tool updates within your organization.

2. Key Topics
   
   

   • Vibe coding as a philosophy:

     1. Reflecting on outcomes from the course and how vibe coding promotes creativity.

   • Evolution of Code Assistants:

     1. More specialized models (by language, by domain).

     2. Integrations with chat agents that cover the entire stack (frontend, backend, infra).

   • Internal Training Strategies:

     1. Establishing an “AI Center of Excellence” to continuously evaluate new tools.

     2. “Pairing with AI” programs for developers to learn best practices.

   • Risks and Considerations:

     1. Over-reliance on AI.

     2. Security gaps.

     3. Scalability costs.

3. Final Exercise
   
   

   • Mini-Hackathon integrating all course elements:

     1. Heavy use of code assistants.

     2. Automatic test generation (Meticulous or similar).

     3. AI-driven CI/CD pipeline.

     4. Basic benchmarks for comparison.

     5. Vibe coding with rapid iteration and documentation-first on part of the project.

   • Present the final prototype and conduct a retrospective about each team’s experience.