CHIP 10.5: AI Tools and Use

These rules are subject to change during the project. The version on this page is authoritative; changes will be announced on Ed.

This page is the CHIP 10.5 version of the course AI Policy. Where the two differ, this page wins for the project; everywhere else in the course, the course policy applies. Back to the project overview.

Table of contents

  1. The short version
  2. Why the project is different
  3. What is allowed
  4. What is required
  5. What is not allowed
  6. Your team’s AI working agreement
  7. Tips for using agents well on this project
  8. Questions?

The short version

  • Agents are allowed. You may use coding assistants and agents (Codex, Claude Code, Cursor, Copilot, Gemini, and similar) to plan, write, test, review, and debug code on CHIP 10.5.
  • You own what you ship. Every team member must be able to explain any line of code the team merges, whether a person or a model wrote the first draft. Code review does not stop being your job because an agent opened the pull request.
  • Disclose it. Every iteration asks how you used AI: the team deliverable (C) asks for your tools, what each person used them for, and one example with the chat linked; your individual retrospective (D) asks for at least two of your own chat links and which was most useful. Specific and honest answers get full credit — so does “we didn’t use it”, if that’s true.
  • Some things stay human. Retrospectives, teammate evaluations, your demo video narration, and the planning conversation itself are yours to write and say.

Why the project is different

The earlier CHIPS taught you a skill with the tools turned off, the way a music student practices scales. CHIP 10.5 simulates a real Agile team, and real teams in 2026 ship with AI tools in the loop. We want you to learn to use them the way a good engineer does: as a fast, tireless, and occasionally wrong junior colleague whose work you must specify, review, and test.

The grade for the project is mostly about process and the result: stories, branches, pull requests, reviews, tests, coverage, a working deployment, and a team that communicated. AI tools can help with all of that, but they cannot do the process for you.

What is allowed

You and your teammates may:

  • Use autocomplete, chat assistants, and autonomous coding agents to write application code, tests, Cucumber features and step definitions, migrations, and configuration.
  • Ask an assistant to explain the legacy codebase, a stack trace, a failing spec, or a gem’s API.
  • Use an assistant to draft user stories and lo-fi mockups from the spec, as input to your planning meeting. The team still decides, points, and assigns the stories together.
  • Use AI-powered review tools on pull requests, in addition to a human review from a teammate.
  • Use an assistant to help write commit messages, pull request descriptions, and the README.
  • Use an assistant to help you prepare your demo, e.g. to outline what to show.

What is required

If you use AI tools, you must also:

  • Review every change before it is merged. The teammate who reviews a pull request must read the diff, not just the assistant’s summary of it, and should leave at least one substantive comment or question.
  • Keep the tests honest. AI-written tests count only if they test behavior. Specs that assert nothing, stub the code under test, or exist only to lift the coverage number will be treated as if they were not there, and may cost points under the testing rubric.
  • Keep your chats. The Gradescope forms ask for links to (or exported transcripts of) the chats behind your work. Use tools that give you a shareable link, or save transcripts as you go — you cannot reconstruct them at the deadline.
  • Answer the AI questions on Gradescope yourself. Deliverable C’s Generative AI question (team) and deliverable D’s AI chats question (individual) are graded on specificity and honesty: name the tools, what each person used them for, and give a concrete example of correcting a model’s output or of a prompt that needed no changes. Generic answers get half credit.
  • Tell your reviewer. When a model wrote most of a change, say so in the pull request description so the reviewer knows to read it more carefully.
  • Protect credentials. Do not paste API keys, .env files, or credentials.yml.enc keys into any chat tool or agent configuration that leaves your machine. Agents that read your repo should be run with the same care as any other program with access to it.
  • Agree as a team. At your first planning meeting, write down your team’s AI working agreement (see below) in your planning document.

What is not allowed

  • Submitting code, tests, or written work you cannot explain. Staff may ask any team member to walk through any part of the codebase during grading.
  • Using AI to write your retro board contributions, the Teammates peer review and self-assessment, or the reflections on the Gradescope forms. These are about your own experience; a model has nothing to add.
  • Using a synthesized voice or generated footage in place of a real walkthrough in your demo video. Editing tools are fine; the demo must be your team showing your deployed app.
  • Letting an agent merge its own pull request or approve a review on a teammate’s behalf. Merges and approvals are human actions on this project.
  • Uploading course materials that are not already public (staff solutions, grading rubrics with internal notes, quiz or exam questions) to AI services, or using them to train or fine-tune public models. The starter repo and the spec are public and are fine to share with a tool.
  • Generating fake activity: commits, issues, reviews, or PR comments produced to look like process rather than to do work.

Violations are handled under the course academic integrity policy.

Your team’s AI working agreement

Spend ten minutes at your first planning meeting answering these questions and record the answers in your planning document. You can change them at any retrospective.

  1. Which tools will we use, and does everyone have access to them?
  2. How will we collect chat links and transcripts during the iteration so the Gradescope questions are easy to answer?
  3. What does “reviewed” mean for us? For example: the reviewer runs the branch locally, reads every file in the diff, and checks that new specs fail without the change.
  4. When will we not use an agent? Many teams reserve the first story of an iteration, or anything touching authentication or payments, for hand-written code so everyone understands the core of the app.
  5. How will we keep stories small enough that an agent’s output is reviewable?

Tips for using agents well on this project

  • Plan first, then prompt. Agents do their best work on a 1-point story with a clear Cucumber scenario. Vague prompts produce large, unreviewable diffs.
  • Make the agent run the tests. Ask it to run bundle exec rspec and bundle exec cucumber before it declares victory, and read the output yourself.
  • Keep diffs small. One story per branch and per pull request. If an agent touched twenty files, split the work before asking for a review.
  • Treat suggestions as suggestions. Legacy code often has a reason for looking the way it does. Check git blame and the existing specs before accepting a sweeping refactor.
  • Review the reviewer. AI review comments can be wrong with great confidence. The human reviewer decides what is a real problem.
  • Budget the time you save. Teams that finish features early should spend the time on coverage, accessibility scenarios, and the deployment, which is where the rubric rewards you (see Overview and Grading).

Questions?

Ask on Ed (publicly if you can, so other teams benefit) or in office hours. If you are not sure whether something is allowed, ask before you do it.


Back to Top

Accessibility Nondiscrimination

Copyright ©2026, Regents of the University of California and respective authors.

This site is built following the Berkeley Class Site template, which is generously based on the Just the Class, and Just the Docs templates.

View all course offerings