Will Computer Science Majors Become Extinct with the Rise of AI?

I want to share my thoughts on a question that’s been on everyone’s mind: Will Computer Science Majors Become Extinct with the Rise of AI?

Here’s a snippet of my vibe coding session this morning for my open-source scheduling and reminder project Pelita, which I’m building for a non-profit organization.

The Conversation

Freddy:

I want to add a reminder system for scheduled members for an event. The reminder will be sent via SMS and email. SMS will use Twilio, and email will use SendGrid. Let's set a default reminder for 3 days before the event. Create a configuration at the event type level.

Recipients can unsubscribe via both email and SMS. Please create an unsubscribe link so users can opt out. On ALL email templates, please put an unsubscribe footer. Users should be able to customize the email template or SMS content. Please add a parameter—name would be enough for now—so it's personalized.

AI:

I think this is a solid feature concept! Let me break down my thoughts and ask some clarifying questions to help us design this well:

Initial Thoughts

Good aspects of your proposal:
- Event type-level configuration makes sense - different event types may need different reminder strategies
- 3 days default is reasonable
- Unsubscribe functionality is critical for compliance (CAN-SPAM, GDPR, etc.)
- Template personalization with parameters is user-friendly

Questions & Considerations

1. Reminder Configuration Scope

You mentioned event type level, but should we also allow:
- Organization-level defaults (that event types inherit)?
- Per-event overrides (for special occasions)?
- Individual member preferences (some prefer SMS, others email)?

2. Multiple Reminders

- Should we support multiple reminders? (e.g., 7 days + 3 days + 1 day before)
- Or stick with single reminder per event type for now?

3. Unsubscribe Granularity

When a member unsubscribes, what should happen:
- Option A: Unsubscribe from ALL event reminders (both SMS & email)?
- Option B: Unsubscribe per channel (email only, SMS only, or both)?
- Option C: Unsubscribe per event type (still get reminders for Sunday services but not for committee meetings)?
- Option D: Complete opt-out from all organization communications?

4. Template System

For customization:
- Should templates be per event type or organization-wide?
- Available parameters - you mentioned {name}. Should we also include:
  - {event_name}
  - {event_date}
  - {event_time}
  - {event_location}
  - {position_name} (their role in the event)
  - {organization_name}
  - {days_until_event}

5. Reminder Scheduling

- How should reminders be sent? Queue job scheduled at specific time?
- What time of day should reminders go out? (configurable per event type?)
- What happens if event date changes after reminder is sent?

6. Database Design Considerations

Should we track:
- Reminder delivery status (sent/failed/bounced)?
- Whether recipient opened email or clicked SMS link?
- Unsubscribe history (when, which channel, which event type)?

7. SendGrid Integration

- Do you already have SendGrid configured, or should we set that up too?
- Should we use SendGrid's unsubscribe groups for better deliverability?

8. Edge Cases

- What if member is scheduled for event but reminder is < 3 days away? Send immediately or skip?
- What if member is removed from event after reminder sent?
- Should admins be able to manually trigger reminders?

Suggested Architecture (Preliminary)

event_types table:
- reminder_enabled (boolean)
- reminder_days_before (integer, default 3)
- reminder_time (time, e.g., '09:00:00')
- email_template_id (nullable)
- sms_template_id (nullable)

communication_preferences table:
- member_id
- organization_id
- email_reminders_enabled (boolean, default true)
- sms_reminders_enabled (boolean, default true)
- unsubscribed_at (timestamp, nullable)

email_templates / sms_templates tables:
- event_type_id (nullable - null means organization default)
- organization_id
- subject (email only)
- content (with parameter placeholders)

reminder_logs table:
- member_id
- event_id
- channel (email/sms)
- sent_at
- status (pending/sent/failed/bounced)
- opened_at (nullable)

What Do You Think?

I had 3 more rounds of prompts after this before the AI actually implemented the feature.

Sure, people can just give a vague prompt like “Build the next social media for me” without any deep understanding of software and let the AI agent work freely—but the question is: How’s the user experience? Will the AI agent build good software? Is it secure? Is it maintainable?

Do you think computer science majors will become extinct, or will they evolve?

---

My Take: CS Majors Won’t Be Extinct—They’ll Evolve

This conversation above is a perfect example of why Computer Science majors aren’t going extinct. Look closely at what actually happened:

What the AI Actually Did

The AI didn’t just “build the feature.” Instead, it:

• Raised critical architecture questions
• Identified compliance concerns (CAN-SPAM, GDPR)
• Thought about edge cases I hadn’t mentioned
• Proposed a database schema for review

But notice what this required from me:

1. Write a clear technical prompt (I knew to mention Twilio, SendGrid, event type configuration)
2. Understand the architectural questions being asked
3. Make decisions on 8+ design choices
4. Evaluate whether the proposed solution was actually good

The Evolution of CS Skills

Old CS workflow: Write every line of code yourself

New CS workflow:

• System design & architecture decisions
• Prompt engineering & requirement specification
• Code review & security analysis
• Integration & orchestration
• Performance optimization
• Evaluating AI-generated solutions

Why CS Knowledge Is Actually More Valuable Now

My “vibe coding” example shows that someone still needs to:

Understand the domain deeply:

• Why did I specify event type level config? (Domain understanding)
• Why 3 days default? (Business logic knowledge)
• Why mention compliance? (Understanding of legal requirements)

Make architectural decisions:

• Should unsubscribe be per-channel or global?
• How do we handle edge cases when events change?
• What should we track in the database?
• How should we structure the data model?

Ensure quality:

• Is the generated code secure?
• Is it maintainable?
• Does it scale?
• Are there race conditions?
• Will this create technical debt?

None of these go away with AI—they become more important because you can build faster, so bad architectural decisions compound faster too.

The Real Answer to My Question

I asked: “Will the AI agent build good software? Is it secure? Is it maintainable?”

The answer is: Only if the human guiding it knows what good software looks like.

AI is an incredible accelerator, but it needs:

• Someone who understands software architecture
• Someone who can spot security vulnerabilities
• Someone who knows when the AI’s “reasonable defaults” are actually terrible for your use case
• Someone who can maintain and evolve the system over time
• Someone who can ask the right questions

The CS Major of the Future

Instead of going extinct, the major is evolving to focus on:

• Software architecture - More important than ever when you can generate code quickly
• System design - AI needs direction on how components fit together
• Security - AI can introduce vulnerabilities if not supervised
• Distributed systems - Complexity doesn’t disappear with better tools
• Domain modeling - Translating business needs into technical requirements
• AI/ML literacy - Understanding when and how to use AI tools effectively
• Code review & quality assurance - Evaluating AI output critically
• Technical leadership - Making decisions AI can’t make

The Analogy

Think of it this way: Civil engineers didn’t become extinct when we invented bulldozers and cranes. They just stopped digging ditches by hand and started designing more complex structures like skyscrapers and bridges.

The tools got better, so the engineers could tackle bigger problems.

Conclusion

My “vibe coding” session actually proves the point—I needed CS knowledge to have that conversation effectively. Without understanding:

• How APIs work (Twilio, SendGrid)
• Database design principles
• User authentication and preferences
• Compliance requirements
• System architecture

I couldn’t have written that initial prompt, evaluated the AI’s questions, or made informed decisions about the implementation.

The future of CS isn’t extinction—it’s evolution. We’re moving from manual coding to software architecture and system design at scale. The CS major who understands this will be more valuable than ever.

The question isn’t whether CS will survive. The question is: Are CS programs adapting fast enough to teach these new skills?