Feedback Playbook for Technical Courses

By this point in the semester, the honeymoon is over. Students have hit their first complex coding project, circuit simulation, or data analysis lab, and many of them are hitting a wall. The feedback you give at this moment does real work. It shapes confidence, persistence, and students’ internal sense of what quality looks like in your discipline.

In technical disciplines, “good job” isn’t enough, and “wrong” is frustrating without context. Research tells us that feedback is most effective when it’s specific, timely, and actionable (Shute, 2008). But in STEM courses, we also need it to be efficient for you as a faculty member with several responsibilities,  and accessible across a wide array of learner backgrounds. So, here’s how to provide high-impact feedback without losing your entire weekend to the grading pile.

This post focuses on how to use rubrics, short screencasts, and carefully chosen AI tools to deliver feedback that is specific, humane, and sustainable without turning grading into a second job.

In computing, engineering, and data-focused courses, the first major assignment is often the point where students encounter professional-level complexity for the first time. Many report that feedback feels generic, delayed, or disconnected from how they can improve. In programming courses in particular, feedback frequently centers on whether something works, rather than how well it is designed, documented, tested, or maintained (Hundhausen et al., 2013; Keuning et al., 2018). Research consistently shows that feedback is most powerful when it helps students answer four questions: Where am I going? How am I doing? Where to next? What strategies will help me improve? (Hattie & Timperley, 2007). Other work shows that students also need support to actively engage with feedback, not just receive it, for it to influence learning (Winstone et al., 2017).

The goal is to structure feedback so students can answer those questions for themselves while keeping your workload manageable.

Strategy 1: Make Rubrics Do the Heavy Lifting

Well-designed rubrics turn vague judgment into transparent expectations. When rubrics include descriptive performance levels and are shared before students begin the work, they improve learning outcomes and student satisfaction (Reddy & Andrade, 2010; Andrade & Du, 2007). In technical courses, rubrics also make implicit professional norms visible, assessable, and discussable (Winkelmes et al., 2016).

Common rubric problems in technical disciplines include broad categories like “Code Quality: 0–25 points,” binary “works or doesn’t work” distinctions, and descriptors such as “good documentation” without observable indicators. These approaches provide little guidance for improvement and often lead to repetitive instructor commenting (Nicol & Macfarlane-Dick, 2006).

A stronger rubric distinguishes performance levels for criteria such as code organization, error handling, testing, documentation, security practices, and version control. For example, exemplary error handling might include meaningful user messages, logging, and graceful failure, while beginning-level work might include crashes, unhandled input, and no diagnostics.

Three moves you can implement right now:

Align each rubric criterion with a specific learning objective and an authentic professional practice such as test coverage, branching strategy, or secure queries (Winkelmes et al., 2016).

Share the rubric when you assign the work and ask students to self-assess against it before submission. This supports metacognition and improves performance (Andrade & Du, 2007; Nicol & Macfarlane-Dick, 2006).

In advanced courses, co-create parts of the rubric by asking students what distinguishes novice work from expert work. This builds agency and self-regulation (Winstone & Carless, 2020).

When rubrics are doing real instructional work, they reduce repetitive commenting and anchor feedback in shared language.

Strategy 2: 120-Second Over-the-Shoulder Screencast Reviews

Some problems are just inefficient to explain in text. A subtle logic error, a flawed circuit diagram, or a misapplied data transformation is often easier to show than describe. Research on multimedia learning shows that concise audio-visual explanations improve understanding for procedural and spatial tasks (Mayer, 2014) and increase students’ sense of instructor presence (Borup et al., 2013).

Here’s a practical pattern: the 120-second over-the-shoulder review.

Open the student’s code or artifact. Start a quick screencast using a tool (like Adobe Express, Kaltura or Zoom). Spend two focused minutes highlighting strengths and one to three priority issues.

What this sounds like:

“I see what you’re doing here on line 42. You’re reinitializing the counter inside the loop, which is why it never increments. Watch what happens when I move it above the loop.”

Or:

“When debugging, trace variable values step by step instead of changing multiple things at once. That process will help you isolate the break.”

Frame your comments at three levels:

Task: what is happening and why it is incorrect.

Process: strategies the student can reuse in future work.

Self-regulation: reinforcement of productive approaches they are already using.

Avoid feedback about personal traits. Research shows that praise focused on the self has little impact on learning (Hattie & Timperley, 2007). Short screencasts allow students to see expert reasoning in action and have been linked to increased engagement and improved code quality in computing courses (Cavalcanti et al., 2021; Hundhausen et al., 2013).

If grading in Canvas, consider using its built-in Video Feedback feature to keep everything in one place:

Strategy 3: Tiered Feedback So You Don’t Burn Out

Not every student needs the same type or depth of feedback. Research on formative assessment suggests that differentiated feedback can be both more effective and more sustainable for instructors (Shute, 2008; Winstone & Carless, 2020).

For a class of about 30 students, a realistic model looks like this:

Top 20 percent: Brief text comments highlighting exemplary practices and optional stretch ideas. Time per student: two to three minutes.

Middle 60 percent: Five- to seven-minute screencasts focused on two or three rubric criteria that would move the work to the next level.

Bottom 20 percent: Five- to seven-minute screencast plus an invitation to meet, emphasizing growth and support rather than penalty.

This typically adds up to about three hours of feedback time, comparable to detailed written comments but with higher instructional payoff (Ice et al., 2007).

Efficiency improves further if you create two or three short videos addressing common issues and link them instead of repeating the same explanations student by student (Borup et al., 2013).

Adapting Strategy 3 for large-enrollment courses (e.g., 100+ students) requires shifting from individual tiering to collective and automated tiering. While individual screencasts are sustainable for 30 students, they become a “second job” for 150.

Here is how to scale the tiered feedback model without losing the instructional payoff:

The Scaled Tiered Model

In a large course, you can replace individual screencasts with “Problem-Set Debriefs” and automated triggers.

• Top Tier (High Achievers): Use automated “Success” triggers. In platforms like Canvas or Gradescope, you can set a rule that students scoring above 90% receive a pre-written comment praising their specific mastery and providing “stretch” links to advanced professional documentation or extra-credit challenges.

• Middle Tier (The “Global” Feedback): Instead of individual videos, record three 2-minute “Common Pitfall” screencasts based on the most frequent errors identified during grading. Link these videos directly in the rubric or assignment comments so students can see expert reasoning for the specific logic errors they likely encountered.

• Bottom Tier (High Support): Identify students who failed to meet core learning objectives and send a templated, supportive “Check-in” message through the Student Engagement Roster. Invite them to a group “Office Hour Lab” specifically designed to review the foundational concepts they missed, emphasizing growth over penalty.

Strategy 4: Thoughtful Use of AI for Feedback and Grading

AI tools (such as Gradescope) can reduce routine grading work and provide fast correctness feedback, but they are not substitutes for professional judgment. Research shows that automated systems are effective at identifying syntax errors, style violations, and common mistakes, but struggle with design quality, documentation, and nuanced reasoning (Keuning et al., 2018).

Use AI or automated tools to:

Run test suites and identify edge cases. Enforce style and basic security rules. Provide immediate, low-stakes feedback for iteration.

Reserve human review for:

Architecture and design choices. Maintainability and documentation. Security practices and professional conventions.

To keep this ethical and transparent:

Clearly label which rubric criteria are auto-scored and which are human-scored (Holmes et al., 2022). Provide a process for students to request review when automated feedback seems incorrect. Periodically audit AI-assisted scoring for bias or uneven impact (Baker & Hawn, 2021).

You can also frame AI as a learning partner rather than a grader by asking students to document how they used AI tools, rewarding reflective use, and setting clear boundaries around generated content (Kasneci et al., 2023).

Your Implementation Checklist

If you want a minimal, high-impact plan:

Finalize and share a detailed rubric aligned with professional practices (Reddy & Andrade, 2010). Require a brief student self-assessment using the rubric (Andrade & Du, 2007). Set up one reliable screencasting workflow and practice a short review (Mayer, 2014). Plan a tiered feedback scheme so your time is targeted (Shute, 2008). Create two or three short videos for common issues. Clearly explain how automated tools are used and how students can respond (Holmes et al., 2022). Reserve support time for students who are still developing core skills (Kuh, 2008; Winstone et al., 2017).

When feedback shows students what quality looks like, helps them see where they are, and gives them clear next steps, assessment becomes part of learning rather than an endpoint. In technical disciplines, that shift often determines whether students decide they don’t belong or begin to see themselves as capable, growing professionals.

References

Andrade, H., & Du, Y. (2007). Student responses to criteria-referenced self-assessment. Assessment & Evaluation in Higher Education, 32(2), 159–181. https://doi.org/10.1080/02602930600801928

Baker, R. S., & Hawn, A. (2021). Algorithmic bias in education. International Journal of Artificial Intelligence in Education, 32(4), 1052–1092. https://doi.org/10.1007/s40593-021-00285-9

Borup, J., West, R. E., & Graham, C. R. (2013). The influence of asynchronous video communication on learner social presence: A narrative analysis of four cases. Distance Education, 34(1), 48–63. https://doi.org/10.1080/01587919.2013.770427

Cavalcanti, A. P., Barbosa, A., Carvalho, R., Freitas, F., Tsai, Y.-S., Gašević, D., & Mello, R. F. (2021). Automatic feedback in online learning environments: A systematic literature review. Computers and Education: Artificial Intelligence, 2, Article 100027. https://doi.org/10.1016/j.caeai.2021.100027

Hattie, J., & Timperley, H. (2007). The power of feedback. Review of Educational Research, 77(1), 81–112. https://doi.org/10.3102/003465430298487

Holmes, W., Porayska-Pomsta, K., Holstein, K., et al. (2022). Ethics of AI in education: Towards a community-wide framework. International Journal of Artificial Intelligence in Education, 32(3), 504–526. https://doi.org/10.1007/s40593-021-00239-1

Hundhausen, C. D., Agrawal, A., & Agarwal, P. (2013). Talking about code: Integrating pedagogical code reviews into early computing courses. ACM Transactions on Computing Education, 13(3), Article 14. https://doi.org/10.1145/2499947.2499951

Ice, P., Curtis, R., Phillips, P., & Wells, J. (2007). Using asynchronous audio feedback to enhance teaching presence and students’ sense of community. Journal of Asynchronous Learning Networks, 11(2), 3–25. https://doi.org/10.24059/olj.v11i2.1724

Kasneci, E., Seßler, K., Küchemann, S., et al. (2023). ChatGPT for good? On opportunities and challenges of large language models for education. Learning and Individual Differences, 103, Article 102274. https://doi.org/10.1016/j.lindif.2023.102274

Keuning, H., Jeuring, J., & Heeren, B. (2018). A systematic literature review of automated feedback generation for programming exercises. ACM Transactions on Computing Education, 19(1), Article 3. https://doi.org/10.1145/3231711

Kuh, G. D. (2008). High-impact educational practices: What they are, who has access to them, and why they matter. AAC&U. https://www.aacu.org/trending-topics/high-impact

Mayer, R. E. (2014). Cognitive theory of multimedia learning. In R. E. Mayer (Ed.), The Cambridge handbook of multimedia learning (2nd ed., pp. 43–71). Cambridge University Press. https://doi.org/10.1017/CBO9781139547369.005

Nicol, D., & Macfarlane-Dick, D. (2006). Formative assessment and self-regulated learning: A model and seven principles of good feedback practice. Studies in Higher Education, 31(2), 199–218. https://doi.org/10.1080/03075070600572090

Reddy, Y. M., & Andrade, H. (2010). A review of rubric use in higher education. Assessment & Evaluation in Higher Education, 35(4), 435–448. https://doi.org/10.1080/02602930902862859

Shute, V. J. (2008). Focus on formative feedback. Review of Educational Research, 78(1), 153–189. https://doi.org/10.3102/0034654307313795

Winkelmes, M. A., Boye, A., & Tapp, S. (2016). Transparent design in higher education teaching and leadership. Stylus. https://www.routledge.com/Transparent-Design-in-Higher-Education-Teaching-and-Leadership-A-Guide-to-Implementing-the-Transparency-Framework-Institution-Wide-to-Improv/Winkelmes-Boye-Tapp/p/book/9781620368237 IUCAT https://iucat.iu.edu/catalog/20508845

Winstone, N. E., & Carless, D. (2020). Designing effective feedback processes in higher education. Routledge. https://www.routledge.com/Designing-Effective-Feedback-Processes-in-Higher-Education-A-Learning-Focused-Approach/Winstone-Carless/p/book/9780815361633 IUCAT – https://iucat.iu.edu/catalog/20522170

Winstone, N. E., Nash, R. A., Parker, M., & Rowntree, J. (2017). Supporting learners’ agentic engagement with feedback: A systematic review and a taxonomy of recipience processes. Educational Psychologist, 52(1), 17–37. https://doi.org/10.1080/00461520.2016.1207538

SIGCSE Grant Award

Excited to share some wonderful news!
My proposal, "Designing for Authentic Assessment: A Community Toolkit for Generative AI Integration in Computing Education," has been selected to receive a SIGCSE Special Projects grant through @ACM SIGCSE!
I designed this project because I believe we need better frameworks for how we assess student learning in the age of generative AI, not just how we use it. The real challenge in computing education right now isn't adopting AI tools. It's ensuring that students are still developing authentic understanding and critical thinking skills alongside them. This toolkit is my attempt to give educators practical, community-driven resources to do exactly that.
The funding is being allocated through the Consortium for Generative AI in CS Education, a community that is giving this conversation the momentum it deserves.
Proud to be doing this work, and looking forward to seeing what this toolkit becomes.
RECRUITMENT WILL START SOON
If you're working on similar challenges in computing education, I'd love to connect!Learn more about the Consortium for Generative AI in CS Education here: https://teachcswithai.org
#SIGCSE #GenerativeAI #ComputingEducation #ACM #HigherEd #AIinEducation

2026 IU Generative AI Faculty Fellow!

Excited to share that I've joined the Generative AI Faculty Fellows Program!
This opportunity comes at the perfect time. Rather than acquiring more knowledge about AI, I'm now focused on applying what I know to transform teaching and learning in meaningful ways.
The fellowship brings together colleagues committed to ethical, pedagogically-sound AI integration. I'm particularly energized by the collaborative aspect—working alongside peers who understand both the transformative potential and the responsibility that comes with these tools.
My focus? Building systems that enhance student learning while maintaining critical awareness of AI's broader implications. This is about action, not just information.
For those who've followed my recent shift from "just one more course" to actually building: this is what application looks like. And I'm here for it!
Looking forward to sharing what we create together.
#HigherEd #FacultyDevelopment #TeachingAndLearning #GenAI #IU #FacultyFellows #GenAIFacultyFellows #AIInEducation #TeachingInnovation

The Growth Edge: When Learning Gets in the Way of Doing

For too long, I've been a perpetual student, always reaching for the next course, the next certification, the next piece of knowledge. The joy of learning is undeniable, but there's a quiet tension that comes with it: the gap between knowing and doing. Last week, that tension reached a breaking point, and I had a profound realization: it's time to stop learning and start building.

The Catalyst: A Familiar Impulse

It began with Mindvalley's new AI Clone Building program. My finger hovered over the purchase button, a familiar impulse to acquire more knowledge. I've taken Mindvalley courses before, and they've been genuinely valuable. Their approach to teaching AI through a personal development lens, rather than dry technical tutorials, helped me get started with custom GPTs. I'm not here to criticize their offerings.

But this time, something shifted. As I reviewed the program details, a moment of clarity struck me: I already know how to do most of this. And the parts I don't know? I can figure them out.

The Realization: What I Already Know

Mindvalley, in fact, reiterated for me one of the most valuable lessons I still use today: audience reframing. It's not just about building a custom GPT or chatbot, but about teaching that GPT to understand who you're talking to and why it matters. For example, creating workshop materials for skeptical engineering faculty requires a different approach than writing for excited undergraduate researchers. MindValley calls this "context injection," and it's brilliant. This skill transfers to everything I do, from faculty development to coaching and curriculum design. It's fundamental to good teaching and coaching, not just an AI skill.

This realization extended to other areas of my AI journey:

• I've already built custom GPTs. They are straightforward once you understand the basic structure: upload content, set instructions, test, and refine. The technical barrier is not as high as it feels.

• I already understand context injection. I apply it in my faculty development work, coaching conversations, and curriculum design without needing another course.

• I have access to excellent alternative resources. Domestika and Udemy offer technical AI courses for a fraction of the cost. YouTube provides detailed tutorials. My institution offers valuable tools and training. The knowledge is available; I just needed to recognize I can use it.

What truly resonated was this: I wasn't looking for information I didn't have. I was looking for permission to trust what I already know. And that realization? That's the good kind of uncomfortable.

The Shift: From Learning to Building

This shift from perpetual learning to active building is particularly significant now. I recently completed the Gallup Global Strengths Coach course and will soon take the certification exam. While I've informally coached for years, this formal training is opening new doors, allowing me to offer my coaching skills more intentionally. My connectedness strength has never been more relevant; I genuinely love supporting people in finding and reaching their goals.

Suddenly, AI tools are no longer abstract concepts. They are directly connected to the work I'm actively building. The coaching certification provided the urgency and clarity to move from simply acquiring knowledge to applying it to create tangible value.

What I'm Actually Building Now

My focus has sharpened, and I'm now actively engaged in:

• Custom GPTs for coaching contexts. I'm developing assistants trained on my coaching voice to help with client session prep, follow-up materials, and workshop design. These tools will augment, not replace, human interaction, handling administrative tasks so I can focus on actual coaching.

• Audience-adaptive content generation. I'm systematically applying context injection principles. A single workshop outline can now be adapted into five different versions, tailored for early-career faculty, mid-career researchers, or department chairs.

• Streamlined faculty support workflows. I'm automating repetitive tasks like scheduling, resource compilation, and initial feedback drafts. This frees up more time for meaningful conversations that genuinely advance people's goals.

The technical skills are either already present or quickly learnable. What I'm building now is the confidence to trust those skills and act on them.

A New Framework for Learning

Looking back, I've consistently underestimated my ability to figure things out independently. My Top 5 CliftonStrengths (Learner, Ideation, Developer, Achiever, and Connectedness), suggest I'm built for self-directed exploration. Yet, there's been a gap between intellectual understanding and emotional trust.

My Learner strength's growth edge is this: once I achieve competence, I often move to the next learning project instead of fully applying what I've learned. The accumulation of knowledge becomes satisfying in itself. With AI tools, I learned to build custom GPTs and understood the principles, but I didn't fully implement the systems I could use in my coaching and faculty development work. I kept learning more about AI instead of applying what I already knew.

This moment, recognizing I don't need another course but need to build the things I've been planning, is about working with this growth edge. The knowing is done. Now, I'm practicing the doing.

Questions to Ask Yourself

If you're considering more AI training, here are questions worth asking:

• What specific skill are you missing? If you can name it precisely, you can likely find a targeted resource for less money than a comprehensive program.

• Are you looking for information or confidence? Information is widely available. Confidence comes from actually building things and seeing them work.

• What have you already learned that you're not giving yourself credit for? Seriously, make a list. You might be surprised.

• What would you build if you already felt competent? Start building that. Competence follows action, not the other way around.

Resources If You're Building Your Own AI Systems

Since I enjoy helping people learn, here are resources that have genuinely helped me:

For Learning Custom GPT Creation:

• OpenAI's official documentation (free, comprehensive)

• Domestika's "Build Custom AI Assistants" courses ($10-40 - aimed at architects, but has general transferrable skills)

• YouTube tutorials by AI Jason and Matt Wolfe (free, current)

For Content Transformation:

• NotebookLM (free from Google, remarkably effective)

• Claude Projects (what I'm using for this conversation)

• ChatGPT Projects (with Plus subscription, $20/month)

For Automation:

• Zapier (free tier gets you started, then $20-50/month)

• Make.com (more powerful, similar pricing)

For Voice/Avatar Video (if you actually need this):

• HeyGen (free trial, then $29+/month)

• Descript ($12+/month, excellent for audio/video editing too)

Key Principle from Mindvalley Worth Keeping:

Context injection. Always tell your AI: Who is the audience? What's the background? What outcome do you want? What tone is appropriate? This framework transforms generic AI outputs into genuinely useful content.

Conclusion: The Real Lesson

It's Saturday evening. I have custom GPTs and ChatBots I've built before. I have new coaching skills I'm developing. I have a clear sense of what I want to create next.

What shifted this week wasn't learning new information. It was recognizing that I need to stop learning and start building. This is a hard shift for someone whose top strength is Learner. The pull to take "just one more course" is real. The satisfaction of acquiring new knowledge is immediate and tangible.

But building something meaningful from what I've learned requires a different kind of commitment. It means sitting with the discomfort of imperfect execution. It means choosing application over acquisition.

Mindvalley's programs provided foundations I'm genuinely grateful for. The audience reframing skill alone was worth the investment. However, the next phase of my AI learning won't come from another structured course. It will come from actually implementing the systems I've been planning, trusting my Learner, Ideation, and Developer strengths enough to create tools that serve my coaching and faculty development work.

This isn't a rejection of structured learning. It's recognizing when I've learned enough structure to create my own. More importantly, it's recognizing when continued learning becomes a way to avoid the harder work of actually doing. And honestly? That realization feels like growth.

Sometimes the most valuable learning doesn't come from the course you take. It comes from the moment you realize you don't need it anymore. I'm not saying I'll never take another Mindvalley course. I'm saying I've reached a point where I can choose to learn with them strategically, rather than reaching for them automatically because I don't trust my own competence. That's the difference. Now I just need to actually build the things I've been planning. The knowing is done. It's time for the doing.

If you want to talk through your own AI learning journey, coaching development, or just need someone to remind you that you probably know more than you think you do, I'm always up for that conversation. You can find me on LinkedIn or through my website.

A Note on This Post

Yes, I used Claude to help write this. Not because I couldn't write it myself (I’ve written blog posts for years), but because one of the things I've learned about AI is that it's excellent for helping you articulate thoughts you're still forming. The ideas are mine. The realization is mine. The voice is mine. Claude just helped me organize the rambling version into something readable. That's what good AI use looks like: augmenting your work, not replacing it.

The Ethical Tension I'm Still Sitting With

In all honesty, I haven't resolved my feelings about AI's broader impact. I work at Indiana University's Luddy School of Informatics, Computing, and Engineering. AI is central to several things we do. I help faculty integrate it into curriculum, design AI-resilient assessments, think through pedagogical implications.

But I'm also deeply aware of environmental costs, data privacy concerns, and the ways AI systems can perpetuate harm against marginalized communities. Faculty in my own school (people who build these systems) have a wide range of perspectives on appropriate AI use.

I don't think that tension is something to resolve by taking another course. I think it's the ongoing work of using powerful tools thoughtfully. I'm going to keep using AI, and I'm going to keep questioning how I use it. Both things can be true.

Week 3: Making Technical Coursework Matter to Students

The Week Three Reality Check

Let me be direct. Week three is when you lose them.

The novelty has worn off. Students are juggling five courses, jobs, relationships and various other responsibilities. Deadlines are colliding. And at least one student in your room is thinking, “When am I ever going to use Big-O notation in real life?”

The research is clear on what happens next. When students cannot explain how coursework connects to professional practice, they are more likely to disengage, change majors, or do just enough to get by (Margolis & Fisher, 2002; Meyer & Marx, 2014). Expectancy-value theory explains why. Even confident students check out when they do not see task value (Wigfield & Eccles, 2000).

This is not a motivation problem. It is a visibility problem.

Your students already care about the tech world. They follow industry news, track hiring trends, argue about AI tools, and know which companies are growing or cutting teams. Our job is not to convince them the field matters. Our job is to make the connection between the course and the field explicit.

Below are three high-impact strategies you can implement without rebuilding your course.

Strategy 1: Cite Industry Certifications in Your Assignments

Why this works

Industry certifications represent consensus about what practitioners are expected to know. They are public, specific, and regularly updated. Most importantly, students recognize them as legitimate signals of professional value.

The 15-minute transformation

Take an existing technical assignment and add two things:

1. The certification exam domain it aligns with

2. A realistic professional scenario

Before

“Implement a binary search tree with insert, delete, and search operations.”

After

“The AWS Certified Developer exam, Domain 2.3, requires understanding data structure selection for application optimization. You are a junior developer evaluating data structures for a real-time leaderboard that processes 50,000 updates per minute. Implement a binary search tree, then write a one-page technical memo recommending whether this structure fits the use case. Cite time complexity and compare it to alternatives.”

Where to find certification standards

• AWS Certifications: aws.amazon.com/certification

• Google Cloud: https://cloud.google.com/learn/certification

• CompTIA: comptia.org/certifications

• Cisco: https://www.cisco.com/site/us/en/learn/training-certifications/certifications/index.html

• NCEES: ncees.org

• ISC²: isc2.org

• PMI: pmi.org

Research foundation

Situated learning research shows that authentic professional contexts increase motivation and support knowledge transfer (Brown, Collins, & Duguid, 1989; Lave & Wenger, 1991). Guzdial and Tew (2006) found 10–15 percent improvements in retention when students could immediately see professional relevance.

Strategy 2: Let Students Reverse-Engineer Job Descriptions

Implementation: a 40-minute in-class activity

Preparation (10 minutes before class)
Pull 4–6 job postings from LinkedIn or Indeed. Mix experience levels from internships to mid-career. Choose companies students recognize. Most importantly, select postings that genuinely align with your course content.

In-class sequence

Part 1: Analysis (15 minutes)
Students work in groups of three or four. Each group analyzes two job postings and categorizes requirements into technical skills, tools, soft skills, project types, and education requirements.

Part 2: Pattern recognition (10 minutes)
Compile findings as a class. Students are often surprised to see communication and documentation listed in 70–80 percent of technical roles. Prompt discussion with a simple question: “What gaps exist between these requirements and your current skill set?”

Part 3: Course mapping (15 minutes)
Close the loop explicitly.

“This week’s database design project addresses the ‘design scalable data schemas’ requirement that appeared in every data engineering position we analyzed. Your deliverable includes both technical implementation and documentation, which aligns with the communication skills emphasized in most of these postings.”

Make it stick

Reference these connections throughout the semester:

• In assignments: “Builds the API design skills listed in 14 of 18 backend developer roles”

• In lectures: “This is why documentation matters. You identified it in nearly every posting”

• On rubrics: “Professional communication, 20 percent. This aligns with the ‘translate technical concepts’ skill from technical lead roles”

Research foundation

Goal-setting theory shows that specific, meaningful goals improve motivation and performance (Locke & Latham, 2002; Morisano et al., 2010). Studies of computing job descriptions consistently show that employers value professional skills alongside technical competence (Radermacher et al., 2014).

Strategy 3: Teach With This Week’s Tech News

Why current events work

Students already follow tech news. When coursework connects to headlines, relevance becomes immediate rather than hypothetical.

A practical system

1. Set up a news radar (one time, 15 minutes)
Create Google Alerts for your language or field plus terms like vulnerability, breach, or breakthrough. Subscribe to Hacker News, relevant subreddits, and one or two industry newsletters.

2. Build flexibility into your syllabus
Designate one or two responsive assignments that can pivot based on current events. Example language: “Assignment 4 topic will be determined based on current industry developments, announced in Week 5.”

3. Move quickly
Current events have a two-week relevance window.

Examples

Cybersecurity
Following a major breach, students audit a sample application for vulnerabilities, produce a report using the OWASP Top 10 framework, and write an executive summary connecting findings to public reporting.

Cloud computing
After a major provider announcement, students design a cloud architecture for a realistic startup scenario, justify service choices, and compare costs across providers.

Data ethics or informatics
Students analyze a newly released AI model for bias, transparency, and deployment risks using ACM and IEEE ethical frameworks.

Engineering courses
Students analyze a recent infrastructure failure using course methods, examine code compliance, and propose inspection or mitigation strategies.

Research foundation

Authentic assessment and real-world relevance increase engagement and retention (Gulikers et al., 2004; Schell & Janicki, 2013).

Bonus Strategy: Strategic Microlearning for Prerequisites

The problem

Student preparation varies widely. You cannot spend week three reviewing basics without losing half the room.

The solution

Self-paced microlearning modules, three to five minutes each, focused on a single concept.

Why this works

Cognitive load theory and the spacing effect both support short, focused, just-in-time learning (Cowan, 2001; Sweller, 2011; Cepeda et al., 2006).

Example

Before advanced networking topics, provide optional modules on binary conversion, hexadecimal notation, or IP address structure. Each module includes a focused objective, a worked example, a few practice problems, and self-check solutions.

Your Implementation Checklist

• Set up Google Alerts

• Identify two or three relevant certifications

• Review 8–10 job postings

• Build one or two responsive assignment slots into the syllabus

• Create a job description analysis worksheet

• Revise one major assignment to include explicit industry connections

• Run the job description activity

• Add real-world relevance statements to upcoming assignments

• Create microlearning modules for common prerequisite gaps if needed

• Assess breaking news within 48 hours for assignment potential

• Reference job requirements in lectures and rubrics

• Track which connections resonate and refine next term

The Bottom Line

Students in computing and engineering are not unmotivated. They cannot see how coursework connects to what they care about: real work, current technology, and professional competence. The evidence is consistent. When students see personal and professional relevance, they persist longer, invest more effort, and perform better (Hulleman & Harackiewicz, 2009; Hulleman et al., 2010). You do not need to rebuild your course. You need to make visible the connections that experienced faculty already see.

Start small. Revise one assignment. Run one activity. Set up one alert.

Your students are already engaged with the tech world. Help them see how your course prepares them to enter it.