Ethical Frameworks for AI Decisions: Consequences, Duties, and Virtues in Code

1. Why Ethics Matters in AI Decisions

2. Utilitarianism: Outcomes and Cost–Benefit in AI

3. Coding a Simple Utilitarian Decision Rule

This simplified Python example shows how a utilitarian-style decision can be expressed in code for an autonomous vehicle.

It is not realistic engineering, but it highlights how ethical assumptions become numeric parameters.

```python

from dataclasses import dataclass

from typing import List

@dataclass

class Outcome:

description: str

expected number of people harmed

people_harmed: int

average severity on a 0-10 scale

avg_severity: float

probability this outcome occurs if we choose this action

probability: float

def expected_harm(self) -> float:

simple utilitarian cost: expected total harm

return self.peopleharmed * self.avgseverity * self.probability

def chooseminharm(outcomes: List[Outcome]) -> Outcome:

"""Return the outcome with the lowest expected harm."""

return min(outcomes, key=lambda o: o.expected_harm())

Example: two possible maneuvers in a crash scenario

stay_course = Outcome(

description="Stay on course, risk 2 pedestrians",

people_harmed=2,

avg_severity=7.0,

probability=0.6

)

swerve = Outcome(

description="Swerve, risk 1 passenger",

people_harmed=1,

avg_severity=9.0,

probability=0.4

)

best = chooseminharm([stay_course, swerve])

print("Chosen action:", best.description)

print("Expected harm:", best.expected_harm())

```

Reflect while reading the code:

1. Where are the ethical assumptions?

• Treating all persons as equal numbers.
• Compressing complex injuries into a single 0-10 scale.
• Focusing only on physical harm, not rights or justice.

1. How could changing the `expected_harm` formula change the moral behavior of the system?

4. Deontology: Duties, Rules, and Rights in AI

5. Adding Deontological Constraints to the Decision Rule

We now extend the earlier code so the AV refuses options that violate a deontological constraint, even if they have lower expected harm.

```python

from dataclasses import dataclass

from typing import List, Callable

@dataclass

class Outcome:

description: str

people_harmed: int

avg_severity: float

probability: float

simple flag: does this action intentionally target a specific person?

targetsspecificperson: bool = False

def expected_harm(self) -> float:

return self.peopleharmed * self.avgseverity * self.probability

def respectsdeontologicalduties(o: Outcome) -> bool:

"""Very simplified deontological filter."""

Example duty: never intentionally target a specific individual

if o.targetsspecificperson:

return False

return True

def chooseactionwith_duties(outcomes: List[Outcome],

duty_check: Callable[[Outcome], bool]) -> Outcome:

1. Filter by duties

allowed = [o for o in outcomes if duty_check(o)]

if not allowed:

raise ValueError("No action respects the duties. Need a fallback policy.")

2. Among allowed actions, minimize expected harm

return min(allowed, key=lambda o: o.expected_harm())

Example outcomes

option_a = Outcome(

description="Swerve toward one identified pedestrian to avoid many",

people_harmed=1,

avg_severity=9.0,

probability=0.9,

targetsspecificperson=True # violates duty

)

option_b = Outcome(

description="Brake and hold course with uncertain outcome",

people_harmed=3,

avg_severity=5.0,

probability=0.5,

targetsspecificperson=False

)

best = chooseactionwithduties([optiona, optionb], respectsdeontological_duties)

print("Chosen action:", best.description)

print("Expected harm:", best.expected_harm())

```

Notice:

• `option_a` has lower expected harm than some alternatives but is rejected because it violates a duty.
• This structure (constraints first, optimization second) mirrors many real-world AI design patterns and safety standards.

6. Virtue Ethics: Character and Practical Wisdom in AI Design

7. Thought Exercise: Triage AI Under Three Frameworks

Imagine a hospital uses an AI system during a pandemic to prioritize patients for intensive care when beds are scarce.

The AI has to rank three patients for the last available ICU bed:

1. Patient A: 30 years old, high chance of full recovery.
2. Patient B: 70 years old, moderate chance of partial recovery.
3. Patient C: 40 years old, low chance of recovery but is the main carer for two children.

Take a minute and mentally sketch how each framework might guide the design.

Task 1: Utilitarian design

• What might the system try to maximize? (e.g., total life-years, quality-adjusted life years, probability of survival?)
• Which patient is likely to be prioritized, and why?

Task 2: Deontological design

• What rules or rights should constrain the system? Examples:
• No discrimination based on age alone.
• Equal respect: use a lottery among patients with similar medical need.
• How might these constraints change the ranking?

Task 3: Virtue-ethical design

• What would a wise and compassionate clinician consider here?
• How could the AI support that judgment instead of replacing it? For example:
• Presenting information clearly.
• Flagging ethical dilemmas.
• Avoiding overconfident recommendations.

Write down (for yourself):

• One sentence describing how each framework would shape the system.
• One limitation of relying only on that framework in this case.

This exercise mirrors real debates in medical ethics and current guidance on clinical decision support systems.

8. Quick Check: Mixing Optimization and Constraints

Test your understanding of how utilitarian and deontological ideas combine in AI design.

9. Flashcards: Key Terms and Concepts

Use these cards to review the main ethical frameworks and how they map into AI design.

10. Why No Single Theory Is Enough (and What Designers Do Now)