CS 6983: Topics in Computer Science: Forward-Deployed Engineering for AI Solutions

Note

This course should be an elective for MS in CS, AI or DS and will also be co-roomed to accommodate students from the MS in Information Systems, MPS in Analytics and MPS in Applied AI. We may consider extending to appropriate students form the MS in Bioinformatics and MS in Project Management as well.

Course Info

• Instructor: Philip Bogden (planned for Spring 2027)
• Semester Hours: 4

Course Description

Explores modern software engineering by introducing the agile, iterative lifecycle for AI systems. This is the practice of the forward-deployed engineer (FDE), who takes an AI system from requirements through production while embedded with a client team. Students apply standard business case and software engineering practices: company strategy, financial analysis, requirements elicitation, architectural design, version control, automated testing, CI/CD, production monitoring to problems specific to AI systems. Students ideate, elicit and evaluate an AI project business case, design the solution, pick an architecture (retrieval-augmented generation, agentic workflows, fine-tuned models, classical ML), build the data pipeline it depends on, write tests and evals for a probabilistic system, and operate it in production. Requirements and architecture decisions will have to account for real constraints: data governance, cost, performance and security, stakeholder needs, domain-specific requirements. Students work in teams on a semester-long engagement with a partner organization, taking one AI system through the full lifecycle to a deployed, monitored application, and are encouraged to build on experiential projects and software repositories from other courses.

Prerequisites: There are no formal prerequisites, but students must be comfortable reading and writing Python, running code locally, using git/GitHub, working from the command line, and accessing data with SQL and web APIs (e.g., DS 5110 or CS 5610). No prior machine learning theory is required.

Relationship to Existing Courses

• CS 5500 (Foundations of Software Engineering). This course is distinguished by starting well before any code is written: it analyzes a client’s industry and strategy, builds and scores a business case (e.g., TRIAD), and elicits requirements from an actual external stakeholder. Commonalities with CS 5500 include the standard SE methods: requirements, design, testing.
• CS 5610 (Web Development). This course emphasizes the AI delivery lifecycle and data pipelines, as distinct from CS 5610’s web development focus.
• CS 6180 (Foundations for Generative AI). This course treats generative AI techniques -- RAG, agents, and the rest -- as software engineering problems: requirements, architecture, testing, deployment, and operations for a real system built with a client over a full semester. CS 6180 introduces the underlying theory and technique (transformer/LLM foundations, prompt engineering, an introduction to RAG) this assumes.

AI Policy

AI tools (Claude, Copilot, etc.) are expected for code generation, debugging, documentation, business/strategy research, and client communication drafts. The AI policy is:

• Don’t trust; verify.
• Own what you submit.

This means two things in practice. First, you have to verify the work is actually correct before you submit it. Testing and evals are how you do that verification. No AI-generated content, code or model output counts as production-ready until it passes the same tests, evals, and reviews as any other business or software engineering practice. Second, you have to understand and be able to explain every line and every claim you submit. That means you must be able to walk through your own pull request or client deliverable in a review.

Course Learning Outcomes (CLOs)

At the end of this course, the student will be able to:

• Communicate technical work with clarity and credibility across audiences, including executive briefings, technical documentation, and client/user interactions
• Perform requirements engineering and architectural scoping for an AI system
  • Elicit and document stakeholder requirements, functional and non-functional specifications, and accountability (e.g., RACI matrices)
  • Use structured prioritization and opportunity-scoring methods (e.g., TRIAD, Porter’s Five Forces) to scope technical work against organizational and industry constraints
  • Assess an organization’s data pipeline, governance, and technical readiness, and treat that as an architecture input
  • Map a use case to an appropriate architecture and build path, from low-code platforms to self-hosted open-weight models
• Design, build, and test MVP AI systems using AI-assisted development
  • Build RAG pipelines, agentic workflows, and API integrations within enterprise constraints
  • Explain the difference between evals and tests, and implement both to verify a system’s behavior before calling it production-ready
  • Write tests and context files that keep AI-assisted coding on track, and write a pull request that holds up to the same code review as any other change
• Deploy and operate AI systems in production
  • Deploy a working AI application to a target cloud environment (e.g., AWS)
  • Apply governance, security, and ethical frameworks appropriate to the operating environment
  • Design monitoring and evaluation processes, and use them to diagnose and iterate on a deployed system

  Topics

  Requirements engineering and stakeholder analysis (core)

• The FDE as an engineering role embedded with a client team: requirements elicitation, stakeholder communication, executive briefings, and technical documentation
• Stakeholder mapping and RACI matrices
• User stories with role, outcome, and measurable target
• Functional vs. non-functional requirements
• Citizen-developer vs. enterprise IT projects
• Scoping requirements against organizational and industry context: Lean Canvas, Five Forces, PESTLE, Strategic Imperative 8, Moore’s Triangle
• Prioritizing technical requirements with TRIAD (Targeted Review for Impact, Alignment & Delivery)

• Value, ROI, and forced ranking

  Solution design, data pipelines, and data readiness (core)

• AI archetypes: chatbots, RAG, agentic workflows, fine-tuned models, classical ML
• Agents vs. workflows; guardrails and human-in-the-loop checkpoints; when an LLM is the wrong tool
• Data pipelines and readiness: ingestion, transformation, access, quality, trustworthiness, security, governance
• Data classification and AI-use policy as architectural constraints

• Build paths and trade-offs: managed AI projects, low-code platforms, self-hosted open-weight models

  AI-assisted build and test (core)

• Augmented vs. “vibe” coding; context files and harnesses for coding agents
• RAG as a data pipeline for unstructured data: embeddings, chunking, vector databases, grounded prompting
• Tool use: API integrations, structured and unstructured data retrieval
• Tests vs. evals: unit tests, golden eval sets, regression testing
• Verification gates before promotion: code review, confidence thresholds, and human sign-off for AI-generated code and model output

• Version control, pull requests, and code review

  Deployment and acceptance (core)

• CI/CD and promotion through environments
• Deploying to a cloud environment (e.g., AWS)
• User acceptance testing, observability, and measurement
• Responsible AI and operational governance: security, cost and usage, risk mitigation, rollback, human-in-the-loop

• Change management and adoption planning

  Sustain and iterate (core)

• Model diagnostics and tuning
• Pipeline maintenance: stale documents, data drift, and model version changes
• Business diagnostics: ROI and improvement backlog

• Feedback loops; keep, change, or retire decisions

  Enterprise low-code platforms (optional)

• Copilot Studio, Power Automate, and similar platforms

• Connectors, approvals, and publishing to enterprise channels

  Model operations and cost (optional)

• Brokering across model providers based on cost and capability
• Running open-weight models on-premises or in a private cloud

• Fine-tuning vs. retrieval vs. prompting

  Industry verticals (optional)

• Regulated domains (e.g., healthcare, legal, finance) and their data constraints
• Public and government data sources

Core topics will be covered in depth with assignments; optional topics introduce students to possibilities for their team engagements.

The partner engagement as course infrastructure

The course runs on one semester-long team engagement with a partner organization. Each team carries a single use case through every phase of the lifecycle -- business case, requirements, solution design, a tested and deployed MVP, and a sustain-and-iterate plan -- rather than treating each phase as a standalone assignment. Teams pair students with technical and business strengths. To take part, students need working familiarity with:

• Python and a package/environment manager
• git and GitHub (branches, pull requests, code review)
• The command line and a cloud development environment (e.g., GitHub Codespaces)
• SQL and REST APIs
• An AI-assisted coding tool

Resources

No required textbook. Materials are drawn from hands-on labs, case studies, business literature, and AI delivery lifecycle documentation developed for the course. Pressman, Software Engineering: A Practitioner’s Approach (shared reference with CS 5500) is recommended background for SDLC, design patterns, and testing fundamentals.

Assessment

Assessment is based on the team’s phase deliverables from the partner engagement (business case, requirements, solution design record, tested/deployed MVP, sustain-and-iterate plan), individual exercises, and a final presentation to the partner.

Schedule

• Weeks 1-3: Requirements engineering and stakeholder analysis; scoping the partner business and use case
• Weeks 4-6: Solution design, data pipelines, and architecture selection
• Weeks 7-10: AI-assisted build and test (core team build)
• Weeks 11-13: Deployment and acceptance
• Weeks 14-15: Sustain and iterate; final presentations