Claude Code Across the SDLC

Table of Contents

1. Challenge

   Introduction

   In this lab, you'll use Claude Code CLI to explore how AI can improve software development activities beyond writing code. You'll configure project-level guidance with CLAUDE.md, modernize outdated documentation, transform ambiguous requests into structured planning artifacts, apply a writer/reviewer workflow with isolated sessions, and evaluate how changing requirements affect an implementation plan.

   By the end of the lab, you'll understand how Claude Code can support the full software development lifecycle, from planning and documentation through review and adaptation, not just code generation.

2. Challenge

   Setting up Claude Code with CLAUDE.md

   Claude Code automatically reads a CLAUDE.md file from your project and uses it as persistent guidance throughout the session. Instead of repeating instructions in every prompt, you can define coding standards, documentation expectations, and workflow preferences once so Claude produces more consistent results across the software development lifecycle.

   Set up Claude

   To start, set things up using the first Terminal.

   1. Change directories: Enter cd claude_code (in the first Terminal).

      • This directory contains two Python files you will reference throughout the lab.

   2. Open the Claude Code CLI: Enter claude.

   3. Create and initialize the CLAUDE.md file: Enter /init.

      • When prompted, choose the Yes or similar options.
      • Do so when prompted throughout the lab.
      • (In the real world, you would want to consider more carefully what you would let Claude do.)

   4. In the center FILETREE, expand claude_code, and open CLAUDE.md.

   5. At the end of CLAUDE.md, paste the following guidance:

      # Project Instructions
      
      ## SDLC Priorities
      - Clarify requirements before implementing changes.
      - Update documentation when implementation changes.
      - Identify assumptions and potential risks.
      - Recommend testing or validation steps after changes.
      
      ## Code Quality
      - Prefer small, focused changes.
      - Keep solutions readable and maintainable.
      - Avoid unnecessary complexity or dependencies.
      
      ## Response Format
      For implementation tasks:
      1. Explain the approach.
      2. Make the requested changes.
      3. Summarize what changed.
      4. Recommend appropriate validation or testing.
      

   That appended guidance emphasizes activities before and after code generation, along with quality expectations.

   With CLAUDE.md in place, Claude Code will consistently apply these project standards throughout your session. This helps ensure outputs remain aligned with your team's development practices without requiring the same instructions in every prompt.

3. Challenge

   Claude documentation generation

   At the Claude Code CLI, enter the following prompt.

   Using the guidance in `CLAUDE.md`, review `cart.py` and
   generate a `README.md` that accurately documents the current
   implementation. Focus on clarity, implementation intent,
   inputs and outputs, assumptions, limitations, and
   recommended validation steps. Do not change the code, only
   create the documentation.
   

   • This generates a README.md, creating documentation based on cart.py.
   • Documentation will be written for cart.py, because cart_v2.py will function as updated code later in the lab. You will later use Claude to analyze the difference between documentation, code implementation, and expected functionalities.
4. Challenge

   Handling underspecified enhancement request

   Software requests often begin as short, ambiguous feature ideas. In this Step, you'll use Claude Code to transform a vague enhancement request into a structured epic with clear user stories and acceptance criteria. The documentation created in the previous Steps provides the context Claude needs to resolve ambiguity and produce a more complete implementation plan.

   The enhancement request is as follows:

   • Add support for additional discount options and improve the checkout experience.

   You will, in an isolated session, ask Claude to expand the request into an epic containing multiple user stories, identify any assumptions or ambiguities, and propose acceptance criteria for each story. Focus on planning rather than implementation. Ensure the plan is saved to an EPIC.md file.

   Create an epic plan around the request

   1. In the second Terminal, run the cd command:

      cd claude_code
      

   2. Start a new Claude session:

      claude
      

      • You're doing this so it's not biased by anything in the chat, and is basing things solely on the existing files.

   3. Paste the following prompt into the Claude CLI:

      Request: Add support for additional discount options and improve the checkout experience.
      
      Expand the above request as follows:
      - Expand it into an epic containing multiple user stories, no more than three.
      - For each story, propose acceptance criteria.
      - Identify any assumptions.
      - Identify any ambiguities.
      - Focus on planning rather than implementation.
      - Save the epic to the file `EPIC.md`.
      

      • This may take up to three or so minutes to complete.

   Review the generated epic to determine whether it clearly defines the scope, resolves missing details, and creates actionable work items that can guide future development.

   • In the real world, you always need to do this; reviewing AI-generated material is key, and often involves iterating and manual touch ups.
5. Challenge

   Change request severity analysis

   Requirements often change after planning has begun. In this Step, you'll evaluate how a new requirement affects the existing plan by comparing implementation options rather than immediately modifying the code. The goal is to practice assessing scope, complexity, and business impact—a skill that transfers to projects of any size.

   The product team has changed priorities:

   • Instead of adding additional discount codes, the shopping cart must now support multiple international currencies.

   Ask Claude to compare the two options–discount code support versus adding multi-currency support–specifically for cart_v2.py.

   • This code has added logic for discount support.

   Rank each plan based on implementation effort, impact on existing requirements, technical risk, testing effort, and long-term maintainability. Focus on how the plan, user stories, documentation, and test strategy would need to change rather than the specific code changes. Write out the comparison to the file COMPARISON.md.

   Create the comparison document

   1. In the same Claude session you started in the last Step (the second   Terminal), paste in the following:

      New request: Add support for multiple international currencies.
      
      For the new request, follow the previous prompt's guidelines for the former request, and create another epic.
      
      There are two exceptions:
      -  Do not save this epic for the new request to a file.
      -  This new request will be added to the code in `cart_v2.py`.
      
      Compare the previous epic to this new epic, and rank the two epics according to the following criteria:
      - implementation effort
      - impact on existing requirements
      - technical risk
      - testing effort
      - long-term maintainability
      
      Save the resulting comparison to the file `COMPARISON.md`.
      

   2. Review the result as before.

      • Your focus should be on the review of Claude's analysis, identifying which options should be prioritized.
      • Consider how requirement changes can significantly alter project scope and planning, even when working with a small codebase.
      • Like before, in the real world, iterations within Claude while refining the prompt, and/or manual fixes would almost certainly be required.
6. Challenge

   Generate and evaluate test cases

   To finish up, start a separate Claude Code session to create test cases from the product documentation, enhancement request, and the first epic. Keeping this validation session separate from the implementation helps prevent the tests from simply reflecting the assumptions made while writing the code.

   Ask Claude to review README.md, CLAUDE.md, EPIC.md, and COMPARISON.md, then generate test cases that cover expected behavior, edge cases, invalid inputs, and acceptance criteria. Save the results to TEST_PLAN.md without modifying the Python implementation.

   In a separate implementation session, compare the current code against TEST_PLAN.md. Record any missing behavior, ambiguous requirements, or test cases that cannot be evaluated, then revise the plan and product documentation.

   Create test cases

   1. In the second Terminal, enter exit to quit the current session.

   2. Start up a new Claude session: Run claude.

   3. At the Claude Code CLI, enter the following prompt:

      Create a plan for test cases for this project:
      - Review the following four files: `README.md`, `CLAUDE.md`, `EPIC.md`, `COMPARISON.md`
      
      Generate a plan for test cases based on those files, and ensure the test cases cover the following:
      - expected behavior
      - edge cases
      - invalid inputs
      - acceptance criteria
      
      Do not modify the Python files.
      
      Save the plan to the file `TEST_PLAN.md`.
      

   4. Start a new Claude session: Enter exit, then run claude again.

   5. Compare the code to the test plan.

      Compare the plan in `TEST_PLAN.md` to the code in `cart_v2.py`:
      - Specify any behavior that is planned in `TEST_PLAN.md`, but does not yet exist in `cart_v2.py`.
      - List any ambiguous requirements. If there are none, say so explicitly.
      - List any test cases that cannot be implemented, briefly explaining why they cannot be implemented. If all test cases can be implemented, say so explicitly.
      
      Output a revised plan for updating `cart_v2.py` based on the results of the above comparison.
      - Include any required documentation changes to `README.md`.
      - Output the revised plan in markdown format.
      
      Do not modify any files. 
      

   As before, in the real world, you would review, and modify via iterations, and eventually write out the plan to a document.