Claude Code Across the SDLC

Table of Contents

1. Challenge

   Introduction

   In this lab, you'll use the Claude Code CLI to explore how AI can help with software development 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

   If a CLAUDE.md file is in your project directory, Claude Code will include the file's instructions at the start of each session, and use it as guidance throughout that 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.

   Start Claude Code and create a CLAUDE.md file

   Do the following in the Terminal.

3. Challenge

   Claude documentation generation

   Keeping documentation up-to-date is a software development task that's often overlooked, and coding agents like Claude Code can help.

   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.

   Whenever a coding agent analyzes a project and generates an output like this README.md file, it's often useful for a human to review and make any additions or corrections before continuing the conversation.

   Before moving to the next step, do the following; it's not strictly required for this lab, but is something you should always do in your own environment:

   • Open that README.md file and review it.
   • The cart.py file contains a function named calculate_order_total() that has one required and one optional parameter.
     • Did the agent include that detail in the README.md file?
     • What else did it decide to include?
     • Did it include anything you think shouldn't be included?
   • If there's anything that you think should be included in README.md that wasn't, add it now before moving on to the next Step.
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 CLAUDE.md and README.md documentation created in the previous Steps provides the context Claude can use 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.

   Create an epic plan around the request

   You now 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.

   You'll start fresh so the conversation doesn't remember anything that you talked about before, other than what's in the CLAUDE.md file. This is a common technique whenever you start working on a new feature in the same project.

   1. Enter /clear into the Claude Code CLI to clear out the conversation history.

   2. Paste in the following prompt:

      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 minutes to complete.

   When it finishes, review the generated EPIC.md file to determine whether it clearly defines the scope, resolves missing details, and creates actionable work items that can guide future development.

   • Did it follow your prompt directions when creating the epic?
   • Did it propose acceptance criteria for each story, and identify assumptions and ambiguities in each user story?
   • If you want to continue tweaking the epic file, either add or modify it manually, or prompt Claude Code again with more information and instructions to update EPIC.md.
5. Challenge

   Change request severity analysis

   Requirements often change after planning has begun, even after implementation has begun.

   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.

   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. At the Claude Code CLI, 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.
      - This new request will apply to the code in `cart.py`.
      - There is one important difference from the previous prompt: Do
        not save this epic for the new request to a file.
      
      Compare this new epic to the previous epic. 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`.
      

   Like before, review COMPARISON.md.

   • 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.

   In real-world situations, note you'll often need several iterations within Claude Code while refining the prompt and steering the output.

6. Challenge

   Generate and evaluate test cases

   To finish up, you'll create test cases from the four existing .md files, and create a TEST_PLAN.md, comparing this to the current code.

   Create test cases ### Run a comparison

   In another fresh session, you'll compare the plan to an implementation of the first request in cart_v2.py, recording missing behavior, ambiguous requirements, or test cases that cannot be evaluated.

   • Note cart_v2.py contains an implementation of the request for discount codes from Step 4. It abstracts the discount codes into a dictionary, and a function named apply_discount().

   You'll then get Claude to create a revised plan, and have it update documentation accordingly.

   1. Run /clear again.

   2. Have Claude 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. 
      

   Just like you did in the previous Steps, review the plan.

   • In your own environment, you would work with Claude Code to make any further improvements, and when you're satisfied would tell Claude to save it as a local document.