Project and Presentation: Final Project Final Draft (100 Points)

Assignment Goals

The goals of this assignment are:
  1. Apply the technical foundations of AI and large language models to design and implement a working prototype system.
  2. Critically evaluate the ethical and social implications of the chosen project through the lens of the Ursinus Questions.
  3. Communicate design choices and results through a clear technical report and an engaging presentation.

The Assignment

Project Description

The final project is your opportunity to bring together the technical, ethical, and interdisciplinary insights from this course. Working individually or in small teams, you will design, implement, and present an AI-driven system that applies large language models, embeddings, or multi-agent systems to a domain of your choice (e.g., education, art, decision-making, civic life).

Projects should balance technical rigor with critical reflection: you must both demonstrate a functional prototype and analyze the societal/ethical implications of your system, especially with respect to fairness, bias, intellectual property, and responsible deployment.

Possible Project Topics

To help you get started, here are some potential directions drawn from our course readings and discussions:

  • Embodiment and Intelligence: Explore philosophical perspectives (e.g., Mensch’s Levinasian view) on embodiment and compare them with how AI represents intelligence.
  • From-Scratch Neural Networks: Build and analyze a simple neural network without libraries, reflecting on representation choices and their implications.
  • Visualization of Learned Representations: Show how embeddings capture meaning across modalities and examine representation bias.
  • AI Psychosis and Model Drift: Simulate or study when generative models produce unstable/harmful content and suggest mitigation.
  • Diffusion & Multimodal AI: Implement a simple multimodal retrieval or generation pipeline, and discuss implications for creativity and misinformation.
  • Custom Chatbot for a Domain: Build a chatbot for education, healthcare, or civic engagement, analyzing prompt design and ethical safeguards.
  • Personas and Configurations: Experiment with system persona engineering and critique the risks of anthropomorphizing AI.
  • Bias in AI Systems: Show how biased data creates discriminatory outputs, and prototype strategies for mitigation.
  • Hallucinations in LLMs: Evaluate why hallucinations occur and develop methods for detection/correction.
  • Intellectual Property and Data Provenance: Prototype a citation-aware generator to address copyright concerns.
  • AI Governance Simulation: Draft/test governance policies through simulated oversight of a fictional AI deployment.
  • Explainability Tools: Implement a simple explainability method (e.g., saliency maps, attribution) and critique its utility.
  • Psychological Impacts of Generative AI: Study how users perceive creativity and originality in AI outputs.
  • AI as a Collaborative Partner in Humanities/Art: Explore cross-disciplinary applications and their ethical dimensions.

Deliverables

  1. Prototype Implementation
    • A working system implemented in Python (or another approved language) demonstrating the use of AI methods covered in class.
  2. Design Report (6–8 pages)
    • State project goals, methodology, and results.
    • Explain design trade-offs and provide evaluation with figures/tables.
    • Reflect critically on ethical and societal implications.
  3. Presentation (10–12 minutes)
    • Demonstrate your system.
    • Lead a discussion on responsible AI dimensions of your project.
  4. Submission Package
    • Source code with documentation.
    • Scripts/configs for reproducibility.
    • Design report (PDF).
    • Presentation slides.

Submission

In your submission, please include answers to any questions asked on the assignment page, as well as the questions listed below, in your README file. If you wrote code as part of this assignment, please describe your design, approach, and implementation in a separate document prepared using a word processor or typesetting program such as LaTeX. This document should include specific instructions on how to build and run your code, and a description of each code module or function that you created suitable for re-use by a colleague. In your README, please include answers to the following questions:
  • Describe what you did, how you did it, what challenges you encountered, and how you solved them.
  • Please answer any questions found throughout the narrative of this assignment.
  • If collaboration with a buddy was permitted, did you work with a buddy on this assignment? If so, who? If not, do you certify that this submission represents your own original work?
  • Please identify any and all portions of your submission that were not originally written by you (for example, code originally written by your buddy, or anything taken or adapted from a non-classroom resource). It is always OK to use your textbook and instructor notes; however, you are certifying that any portions not designated as coming from an outside person or source are your own original work.
  • Approximately how many hours it took you to finish this assignment (I will not judge you for this at all...I am simply using it to gauge if the assignments are too easy or hard)?
  • Your overall impression of the assignment. Did you love it, hate it, or were you neutral? One word answers are fine, but if you have any suggestions for the future let me know.
  • Using the grading specifications on this page, discuss briefly the grade you would give yourself and why. Discuss each item in the grading specification.
  • Any other concerns that you have. For instance, if you have a bug that you were unable to solve but you made progress, write that here. The more you articulate the problem the more partial credit you will receive (it is fine to leave this blank).

Assignment Rubric

Description Pre-Emerging (< 50%) Beginning (50%) Progressing (85%) Proficient (100%)
Implementation (30%) Provides a working implementation aligned to the assignment specification with simple tests. Implements the core functionality accurately and demonstrates usage on representative inputs. Implements the full specification with clear structure, tests, and discussion of edge cases. Delivers a robust, well-structured implementation with comprehensive tests and justified design choices.
Algorithmic Correctness and Reasoning (30%) Explains the algorithmic approach and verifies outputs on basic cases. Explains design decisions and validates outputs on typical cases with reasoning. Provides correctness arguments and empirical checks across varied cases. Presents clear correctness reasoning and evidence of generalization with insightful error analysis.
Code Quality and Documentation (20%) Organizes code into readable units with brief inline comments. Uses functions/modules and docstrings to clarify behavior and interfaces. Maintains consistent style, meaningful names, and explanatory docs where non-trivial. Exhibits clean architecture, thoughtful abstractions, and thorough documentation throughout.
Design Report (10%) Summarizes goals, approach, and evaluation setup. Explains design decisions and trade-offs with small-scale results. Details design rationale, experiments, and limitations with supporting figures/tables. Delivers a concise, well-structured report with justified choices and actionable future work.
Submission Completeness (10%) Provides required artifacts and basic run instructions. Includes all artifacts with clear run instructions and parameters. Includes scripts, configs, and reproducible steps with sample data. Provides a fully reproducible package with results, seeds, and validation notes.

Please refer to the Style Guide for code quality examples and guidelines.