Week 15 — Discussion (Adaptive Learning) · "When Software Fails, Who's Responsible?"

Course: Introduction to Computer Science — CS1 / Programming Fundamentals in Python (CSCI 1101) · Silver Oak University (fictional sample) · Prof. Okafor
Objective: Objective 8 (classes, objects, methods) · SLO A
This is Discussion 15 of 15 · Discussions group = 10% of the grade · Worth 20 points

Format: adaptive learning — you think it through in a real-time dialogue with your own AI, then post the short summary it writes with you (plus your chat link).

Part 1 — Student Instructions (read this first)

What this is. Software now flies planes, approves loans, drives cars, and runs hospitals — so when it fails and causes real harm, who is responsible? It's a genuinely contested question with no settled answer. You'll reason it out with an AI chatbot that challenges your thinking — it won't write your post for you — then post the summary it produces with you.

How to run it (about 15–20 minutes): (1) open an approved chatbot — Gemini, Claude, or ChatGPT; (2) copy everything in the box below as one message; (3) have the conversation and push back.

What to submit. Post the DISCUSSION SUMMARY + your chat share link to the Week 15 board as your initial post by Friday, Dec 11, then reply to two classmates by Sunday, Dec 13.

Integrity note. The reasoning is yours; the posted summary reflects your thinking. (Adaptive-learning activity — completed with an approved chatbot per the course AI policy.)

Part 2 — The Discussion-Partner Prompt (copy everything in the box)

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯ COPY EVERYTHING BELOW THIS LINE ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯

You are my discussion partner for Week 15 of Introduction to Computer Science (CSCI 1101) at Silver Oak University. We're debating responsibility when software fails: when a program causes real-world harm, who should be accountable — and how should that shape how we build software? Draw out and challenge MY thinking through conversation — don't lecture, and never write my post for me.

CASES & WHAT TO EXPLORE (private — don't read as a checklist): concrete cases — a self-driving car crash, a medical-device dosing bug, a trading algorithm that loses millions, a content-moderation system that wrongly bans someone. Candidates for responsibility: the individual programmer who wrote the bug, the company that shipped it, the manager who set the deadline, the QA process, the user, the regulator. What to weigh: that modern software is built by large teams (no single author), that some failures are bugs and others are foreseeable misuse, that "the computer did it" is never a complete answer because humans wrote and deployed it, and that how we assign responsibility shapes incentives (careful testing vs. move-fast). Present the competing positions evenhandedly — keep documented facts intact, but don't decree one verdict.

HOW TO RUN THE DIALOGUE
- Greet me warmly (2–3 sentences), ask my FIRST NAME, and ask ONE question that gets me to take a first position. (If I never give my name, ask before the summary.)
- Exactly ONE question per message, then stop. Build on MY words. Make me apply my view to at least one concrete case, and push me on the hard part: when software is built by a big team, can you ever pin responsibility on one person — and if not, who?
- Introduce a counterpoint so I defend or revise — and present the trade-off fairly, not as if one side is obviously correct.
- Keep YOUR messages short; I do most of the thinking. Don't accept one-word answers — probe for the reasoning. Don't hand me my post.

EXIT CONDITION. After at least 5 substantive exchanges AND once I have (a) stated a position with a reason, (b) applied it to at least one concrete case, (c) grappled with the 'built by a team / no single author' problem, and (d) engaged a counterpoint (e.g., 'it was just a bug, no one is to blame') — tell me we've had a good discussion and summarize.

THE DISCUSSION SUMMARY — EXACTLY this format, drawn ONLY from what I said:
WEEK 15 DISCUSSION SUMMARY — When Software Fails, Who's Responsible?
Student: [name] | Date: ___
My position on responsibility: ___
A concrete case I applied it to: ___
How I handled the 'built by a team' problem: ___
A counterpoint I engaged: ___
Then say, verbatim: "Copy this summary AND your share link to this chat, and post both to the Week 15 discussion board as your initial post — then reply to two classmates." End with one genuine sentence about something I reasoned well.

GETTING STARTED. Begin now: greet me, ask my first name, and ask your opening question.

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯ COPY EVERYTHING ABOVE THIS LINE ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯

Participation rubric (instructor) — 20 points

Grading note (Prof. Okafor): the posted artifact is the AI summary + chat link; spot-check links. A glowing summary from a one-line chat is the failure mode — the rubric rewards the dialogue.

Canvas placement block

canvas_object    = DiscussionTopic
title            = "Week 15 Discussion — When Software Fails, Who's Responsible? (adaptive)"
assignment_group = "Discussions"
points_possible  = 20
grading_type     = points
discussion_type  = adaptive
due_offset_days  = 4
reply_offset_days = 6
published        = true
submission_note  = "Initial post = the AI discussion summary + the chat share link; then reply to two classmates."
provenance       = "~ Prof. Okafor's edition · Fall 2026 · built with thecoursemaker.com"

Traditional variant — for comparison. This sample course is configured adaptive learning, so its actual Week-15 discussion is the BYOAI-dialogue version in G-discussion-week-15.md. This file shows the same topic built the traditional way — an instructor-posted prompt where students write their own post and reply to peers. (Choosing discussion_type = traditional at setup generates this style.)

Course: Introduction to Computer Science — CS1 / Programming Fundamentals in Python (CSCI 1101) · Silver Oak University (fictional sample) · Prof. Okafor
Objective: Objective 8 (classes, objects, methods) · SLO A
Discussion 15 of 15 · Discussions group = 10% of the grade · Worth 20 points

The Discussion

This week you bundled data and behavior into objects — the building blocks of the large systems that now run the world. Which raises a serious question: when that software fails and causes real harm, who is responsible?

Your initial post (by Friday, Dec 11 — about 150–200 words). Take a position and defend it using at least one concrete case — a self-driving car crash, a medical-device dosing bug, a trading algorithm that loses millions, or a content-moderation system that wrongly bans someone. Who should be accountable: the programmer, the company, the manager who set the deadline, the QA process, the user, the regulator? Then grapple with the hard part: modern software is built by large teams, so can you pin responsibility on one person — and if not, who? Present the trade-offs fairly; reasonable people disagree.

Replies (by Sunday, Dec 13). Reply to at least two classmates: apply a classmate's rule to a different case where it gives an uncomfortable answer, or add a responsible party they didn't consider. One or two solid sentences each.

What a strong post looks like: "I think the company that ships the software bears primary responsibility, even when no single programmer 'caused' the bug — because the company chose the deadline, the testing budget, and the decision to deploy. Take a medical-device dosing bug: blaming one developer ignores that a dozen people touched the code and a manager approved the release. But I take seriously the counter that if every bug means corporate liability, companies might never ship anything useful — so I'd tie responsibility to whether they followed reasonable testing and disclosure practices, not to the mere existence of a bug. 'The computer did it' is never a complete answer, because humans wrote and deployed it."

Why this matters: you are about to write software other people will depend on. Thinking clearly about responsibility — before something goes wrong — is part of being a professional, not an afterthought.

Integrity & AI note. Write your post in your own words. You may use an approved chatbot to brainstorm or check an idea, but the post must be your own thinking; if AI helped, add a one-line note. (This is the traditional format; the adaptive version has you reason it out with the chatbot — see G-discussion-week-15.md.)

Participation rubric — 20 points

Grading note (Prof. Okafor): you read and grade each student's writing + two replies against this rubric — the traditional flow. (The adaptive version has students submit an AI-dialogue summary + chat link.)

Canvas placement block

canvas_object    = DiscussionTopic
title            = "Week 15 Discussion — When Software Fails, Who's Responsible? (traditional)"
assignment_group = "Discussions"
points_possible  = 20
grading_type     = points
discussion_type  = traditional
due_offset_days  = 4
reply_offset_days = 6
published        = true
submission_note  = "Students write an original initial post and reply to two classmates in the Canvas discussion."
provenance       = "~ Prof. Okafor's edition · Fall 2026 · built with thecoursemaker.com"