⏱️ Lectura: 11 min
William & Mary, one of the oldest universities in the United States, announced a new minor combining computer science with applied philosophy in a single curriculum. AI ethics is no longer a one-afternoon elective seminar; it becomes a sequence of required courses for anyone who completes the program.
📑 En este artículo
The decision comes as companies and governments debate how to audit model behavior before it reaches production. According to its own announcement, the university aims to train professionals who understand both the code and the normative questions behind it.
TL;DR
- William & Mary announced a new interdisciplinary minor combining computer science and applied philosophy.
- The program requires computer science students to take applied ethics courses and philosophy students to program AI models.
- The minor joins existing initiatives such as Stanford’s Embedded EthiCS and MIT’s SERC program.
- Open source tools like Fairlearn and AIF360 make it possible to audit algorithmic bias without building a model from scratch.
- Demand for hybrid profiles combining ethics and AI engineering is growing as more companies deploy LLMs in production.
- William & Mary did not publish enrollment figures or an exact course start date in the original announcement.
What Happened
William & Mary, founded in 1693, confirmed on its official website the launch of a minor that combines, within a single curriculum, courses from the computer science department and the philosophy department. The proposal is not an isolated “AI and society” course: it is a sequence of courses that a computer science student takes alongside philosophy students, and vice versa.
The university’s stated goal is that whoever programs a model understands the normative questions raised by AI ethics (who benefits, who is harmed, what assumptions the training data carries) and that whoever raises those questions also understands the real technical limitations of a machine learning system, not a simplified version of how it works.
Context and Background
The idea of teaching ethics within a technical degree, rather than as a separate elective course, did not originate at William & Mary. The most cited precedent is Embedded EthiCS, Stanford’s program that inserts philosophy modules directly into courses on data structures, artificial intelligence, or distributed systems, instead of isolating them in a humanities class. MIT has an equivalent program, Social and Ethical Responsibilities of Computing (SERC), which requires computer science students to reflect on the social impact of what they build before graduating.
What’s different about William & Mary’s case is the format: instead of inserting ethics modules into existing technical courses, the university creates a formal minor, with its own academic credit, that appears on the student’s degree. It’s a stronger institutional commitment than an optional module: it certifies that the student completed a specific sequence of ethics applied to AI systems, not just that they sat through it for an afternoon.
The timing of the announcement isn’t a coincidence either. Public discussion about algorithmic bias and unexpected behavior from language models in production has been running in mainstream media for years, not just in technical publications. Universities training the next generation of AI engineers face growing pressure to deliver not only technical competence but also the judgment to decide when a system shouldn’t be deployed.
💭 Key point: a minor with its own credit requires completing an entire sequence of courses, not an isolated workshop. That changes the student’s incentive: it’s not an anecdote for the resume, it’s a formal certification.
AI Ethics in Code: How Bias Gets Audited
The technical side of programs like this one doesn’t stop at philosophical discussion. Auditing a model for bias is a measurable problem, with concrete metrics and open source tools that any developer can run today against their own pipeline.
The most commonly used metrics compare model behavior across groups defined by a sensitive attribute (gender, age, region, etc.). There’s no single “correct” metric: each measures something different, and in general it’s not mathematically possible to satisfy all of them at once on the same model.
| Metric | What It Measures | When to Use It | Limitation |
|---|---|---|---|
| Demographic parity | That the rate of positive predictions is equal across groups | When the goal is equal access (e.g. credit approval) | Can force the model to ignore real, relevant differences between groups |
| Equalized odds | That the rate of false positives and false negatives is equal across groups | When the cost of an error varies depending on context | Harder to optimize without sacrificing overall accuracy |
| Individual fairness | That similar individuals receive similar predictions | When case-by-case consistency matters | Requires defining a “similarity” metric, which is itself a design decision |
| Counterfactual fairness | That the prediction doesn’t change if only the sensitive attribute is altered | When a reasonable causal model of the domain exists | Requires an explicit causal model, rare in practice |
In practice, an engineering team doesn’t pick a number by hand: it uses a library that calculates these metrics on the model’s actual predictions. Fairlearn, maintained by Microsoft and the open source community, is the most widely used option in Python.
pip install fairlearn
python -c "import fairlearn; print(fairlearn.__version__)"That first step only confirms the library is installed and responding. The real audit happens when you run it against the predictions of an already trained model, with a sensitive attribute identified in the dataset:
from fairlearn.metrics import MetricFrame, demographic_parity_difference
from sklearn.metrics import accuracy_score
metric_frame = MetricFrame(
metrics=accuracy_score,
y_true=y_test,
y_pred=y_pred,
sensitive_features=genero_solicitante
)
dpd = demographic_parity_difference(
y_true=y_test,
y_pred=y_pred,
sensitive_features=genero_solicitante
)
print("Accuracy by group:", metric_frame.by_group)
print("Demographic parity difference:", dpd)A dpd value close to zero indicates the model approves or rejects cases at similar rates across groups. A value far from zero doesn’t by itself prove the model is unfair, but it is the signal that triggers a manual review before approving deployment.
flowchart TD
A["Training data"] --> B["ML model"]
B --> C["Fairness metrics"]
C --> D["Audit report"]
D --> E{"Passes threshold?"}
E -->|"Yes"| F["Deploy to production"]
E -->|"No"| G["Retraining or mitigation"]
subgraph Audit
C
D
E
endThis is, in essence, the kind of workflow that a minor like William & Mary’s tries to get its students to understand from both sides: whoever writes the code that generates the report, and whoever decides what threshold is acceptable and why.
💡 Tip: IBM Research maintains AIF360, another open source toolkit with dozens of fairness metrics and several mitigation algorithms, useful if Fairlearn doesn’t cover your use case.
How to Start Auditing Your Own Models
You don’t need to take an AI ethics minor to apply this today. If you already have a trained classification model and a dataset with at least one identified sensitive attribute, the shortest path is:
- Install Fairlearn (
pip install fairlearn) or AIF360 in the environment where validation predictions run. - Choose a metric based on the table above: demographic parity if the goal is equal access, equalized odds if the cost of error varies by context.
- Run the metric against the validation set, not production, to have room to fix issues before exposing real users.
- Document the result as part of the release checklist, alongside accuracy and other performance metrics, not as a separate report nobody reviews.
The step most teams skip is the last one. It’s easy to run the metric once for an internal report and never look at it again once the model gets retrained with new data. A CI pipeline that runs the fairness audit on every retraining, just like it runs unit tests, prevents that oversight.
Impact and Analysis
The job market is already asking for this hybrid profile, even though it doesn’t yet have a standardized name in job listings. Teams deploying LLMs in production need someone who can read a fairness report and also explain to the legal or product team what that number means and what risk comes with ignoring it.
The most common criticism of these kinds of programs is that ethics “can’t be taught in a classroom” or that it ends up as a veneer over a degree that remains, at its core, purely technical. It’s a valid criticism when the program is reduced to a reading seminar with no connection to actual code. The difference William & Mary claims, like Stanford with Embedded EthiCS, is that the sequence requires producing concrete technical artifacts (audits, metric reports, documented design decisions), not just essays.
The real limitation of this approach is measuring its effect. No university has yet published a longitudinal study comparing the judgment of graduates from programs with an AI ethics minor against graduates without one. William & Mary’s announcement doesn’t include that evidence either: for now, it’s a curricular bet backed by the program design’s logic, not by a measured outcome.
What’s Next
It’s reasonable to expect more universities to follow this path of turning AI ethics into a sequence with its own credit instead of a standalone module, especially since the cost of adding it is relatively low: it requires no new infrastructure, just coordination between two departments that already exist. The harder question isn’t whether it’s taught, but whether the companies hiring these graduates give them real room to halt a deployment when the audit comes back bad.
That is, ultimately, the blind spot of any academic program: a student can graduate knowing exactly how to interpret a demographic parity difference and still lack the organizational authority to block a release. The minor solves the knowledge part. The decision-making power part stays outside the classroom.
⚠️ Heads up: knowing how to calculate a fairness metric isn’t the same as having the authority to halt a deployment. That depends on each company’s culture and decision-making structure, not on the university curriculum.
📖 Summary on Telegram: View summary
Try it yourself: install Fairlearn with pip install fairlearn and run demographic_parity_difference against your own model’s validation predictions today.
Frequently Asked Questions
Which universities already combine ethics and computer science in a formal program?
Stanford has Embedded EthiCS, which inserts philosophy modules into existing technical courses. MIT has the SERC program (Social and Ethical Responsibilities of Computing). William & Mary now adds a minor with its own academic credit that combines both departments in a formal sequence.
What is demographic parity in an AI model?
It’s a fairness metric that compares a model’s rate of positive predictions across different groups defined by a sensitive attribute, such as gender or age. A difference close to zero indicates the model approves or rejects cases at similar rates across those groups.
Does studying philosophy help when working as an AI engineer?
It helps precisely formulate what a model is being asked to optimize for and what error costs are acceptable, which are normative decisions, not just technical ones. It doesn’t replace the programming and statistics knowledge the job requires.
What free tools exist to audit bias in your own model?
Fairlearn, maintained by Microsoft and the open source community, and AIF360, from IBM Research, are the two most widely used Python libraries. Both are free and open source.
Does this minor replace a computer science degree?
No. It’s a complement: a minor is taken alongside a primary degree (major), not in place of one. A computer science student who completes this minor adds the applied ethics sequence to their primary degree, they don’t replace it.
References
- William & Mary News: official announcement of the new interdisciplinary minor.
- Fairlearn: official documentation for the open source library to audit fairness in ML models.
- AIF360 on GitHub: IBM Research’s toolkit for detecting and mitigating algorithmic bias.
- Ethics of artificial intelligence, Wikipedia: general overview of the field and its main debates.
- Embedded EthiCS, Stanford: program that integrates ethics directly into computer science courses.
📱 Enjoying this content? Follow @programacion on Telegram for daily tech content in Spanish: quick summaries, fresh content every day.
Imagen destacada: Foto de Brecht Corbeel en Unsplash
0 Comments