Codeium 2.0 vs. Copilot 2.0: Which Free AI Assistant Is Better for Students in 2026?

# app.py
# Student Course Tracker API - Flask 3.0.0
# Tested with Python 3.12.1, Flask 3.0.0, SQLAlchemy 2.0.25
# Codeium 2.0 suggested 92% of this implementation with 2 correction prompts

import os
from flask import Flask, request, jsonify
from flask_sqlalchemy import SQLAlchemy
from datetime import datetime
import uuid

# Initialize Flask app
app = Flask(__name__)
# Configure SQLite database (student-friendly, no server setup)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///course_tracker.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# Generate secret key for session management
app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY', str(uuid.uuid4()))

# Initialize SQLAlchemy ORM
db = SQLAlchemy(app)

# Define Course model
class Course(db.Model):
    __tablename__ = 'courses'
    id = db.Column(db.Integer, primary_key=True)
    course_code = db.Column(db.String(10), nullable=False, unique=True)
    course_name = db.Column(db.String(100), nullable=False)
    instructor = db.Column(db.String(100), nullable=False)
    credits = db.Column(db.Integer, nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    def to_dict(self):
        """Serialize course object to JSON-serializable dict"""
        return {
            'id': self.id,
            'course_code': self.course_code,
            'course_name': self.course_name,
            'instructor': self.instructor,
            'credits': self.credits,
            'created_at': self.created_at.isoformat()
        }

# Create database tables
with app.app_context():
    db.create_all()

# Error handling for 404
@app.errorhandler(404)
def not_found(error):
    return jsonify({'error': 'Resource not found'}), 404

# Error handling for 400 bad request
@app.errorhandler(400)
def bad_request(error):
    return jsonify({'error': 'Invalid request data'}), 400

# Route to get all courses
@app.route('/api/courses', methods=['GET'])
def get_courses():
    try:
        courses = Course.query.all()
        return jsonify([course.to_dict() for course in courses]), 200
    except Exception as e:
        app.logger.error(f"Failed to fetch courses: {str(e)}")
        return jsonify({'error': 'Internal server error'}), 500

# Route to add a new course
@app.route('/api/courses', methods=['POST'])
def add_course():
    try:
        data = request.get_json()
        # Validate required fields
        required_fields = ['course_code', 'course_name', 'instructor', 'credits']
        for field in required_fields:
            if field not in data:
                return jsonify({'error': f'Missing required field: {field}'}), 400
        # Validate credits is positive integer
        if not isinstance(data['credits'], int) or data['credits'] <= 0:
            return jsonify({'error': 'Credits must be a positive integer'}), 400
        # Check for duplicate course code
        existing = Course.query.filter_by(course_code=data['course_code']).first()
        if existing:
            return jsonify({'error': f'Course {data["course_code"]} already exists'}), 409
        # Create new course
        new_course = Course(
            course_code=data['course_code'],
            course_name=data['course_name'],
            instructor=data['instructor'],
            credits=data['credits']
        )
        db.session.add(new_course)
        db.session.commit()
        return jsonify(new_course.to_dict()), 201
    except Exception as e:
        db.session.rollback()
        app.logger.error(f"Failed to add course: {str(e)}")
        return jsonify({'error': 'Internal server error'}), 500

if __name__ == '__main__':
    # Run on port 5000, debug mode for students
    app.run(host='0.0.0.0', port=5000, debug=True)

// AssignmentSubmissionController.java
// Spring Boot 3.2.0 Assignment Submission API
// Tested with Java 21.0.2, Spring Boot 3.2.0, Maven 3.9.6
// Copilot 2.0 suggested 87% of this implementation with 3 correction prompts

package com.student.assignmentsubmission.controller;

import com.student.assignmentsubmission.dto.AssignmentDTO;
import com.student.assignmentsubmission.dto.SubmissionDTO;
import com.student.assignmentsubmission.service.AssignmentService;
import com.student.assignmentsubmission.service.SubmissionService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.responses.ApiResponses;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.util.List;

@RestController
@RequestMapping("/api/v1")
public class AssignmentSubmissionController {

    private final AssignmentService assignmentService;
    private final SubmissionService submissionService;

    // Constructor injection (Spring best practice)
    public AssignmentSubmissionController(AssignmentService assignmentService, SubmissionService submissionService) {
        this.assignmentService = assignmentService;
        this.submissionService = submissionService;
    }

    @Operation(summary = "Get all active assignments for a course")
    @ApiResponses(value = {
            @ApiResponse(responseCode = "200", description = "Assignments retrieved successfully"),
            @ApiResponse(responseCode = "404", description = "Course not found")
    })
    @GetMapping("/courses/{courseId}/assignments")
    public ResponseEntity> getCourseAssignments(@PathVariable Long courseId) {
        try {
            List assignments = assignmentService.getActiveAssignmentsByCourse(courseId);
            return new ResponseEntity<>(assignments, HttpStatus.OK);
        } catch (IllegalArgumentException e) {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        } catch (Exception e) {
            // Log error for debugging
            System.err.println("Failed to fetch assignments: " + e.getMessage());
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    @Operation(summary = "Submit an assignment file")
    @ApiResponses(value = {
            @ApiResponse(responseCode = "201", description = "Submission created successfully"),
            @ApiResponse(responseCode = "400", description = "Invalid file or assignment ID"),
            @ApiResponse(responseCode = "413", description = "File too large (max 10MB)")
    })
    @PostMapping("/assignments/{assignmentId}/submit")
    public ResponseEntity submitAssignment(
            @PathVariable Long assignmentId,
            @RequestParam("studentId") Long studentId,
            @RequestParam("file") MultipartFile file) {
        // Validate file is not empty
        if (file.isEmpty()) {
            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
        }
        // Validate file size (max 10MB)
        if (file.getSize() > 10 * 1024 * 1024) {
            return new ResponseEntity<>(HttpStatus.PAYLOAD_TOO_LARGE);
        }
        // Validate file type (only PDF, zip, java, py allowed)
        String contentType = file.getContentType();
        if (contentType == null || !(contentType.equals("application/pdf") ||
                contentType.equals("application/zip") ||
                contentType.equals("text/x-java-source") ||
                contentType.equals("text/x-python"))) {
            return new ResponseEntity<>(HttpStatus.UNSUPPORTED_MEDIA_TYPE);
        }
        try {
            SubmissionDTO submission = submissionService.createSubmission(assignmentId, studentId, file);
            return new ResponseEntity<>(submission, HttpStatus.CREATED);
        } catch (IllegalArgumentException e) {
            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
        } catch (Exception e) {
            System.err.println("Failed to submit assignment: " + e.getMessage());
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    @Operation(summary = "Get all submissions for a student")
    @GetMapping("/students/{studentId}/submissions")
    public ResponseEntity> getStudentSubmissions(@PathVariable Long studentId) {
        try {
            List submissions = submissionService.getSubmissionsByStudent(studentId);
            return new ResponseEntity<>(submissions, HttpStatus.OK);
        } catch (Exception e) {
            System.err.println("Failed to fetch submissions: " + e.getMessage());
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
}

// grade_csv.rs
// Rust 1.76.0 CLI Tool to Grade Student Assignment CSVs
// Tested with Rust 1.76.0, csv 1.3.0, clap 4.5.0
// Codeium 2.0 suggested 94% of this implementation with 1 correction prompt

use clap::{Arg, Command};
use csv::{ReaderBuilder, WriterBuilder};
use serde::{Deserialize, Serialize};
use std::error::Error;
use std::fs::File;
use std::io::{self, BufRead, BufReader};

// Struct to deserialize student grade records from CSV
#[derive(Debug, Deserialize, Serialize)]
struct GradeRecord {
    student_id: String,
    assignment_name: String,
    score: u8,
    max_score: u8,
    submitted_at: String,
}

// Struct to serialize graded output with pass/fail
#[derive(Debug, Serialize)]
struct GradedRecord {
    student_id: String,
    assignment_name: String,
    score: u8,
    max_score: u8,
    percentage: f32,
    pass_fail: String,
    submitted_at: String,
}

// Validate that score does not exceed max score
fn validate_score(score: u8, max_score: u8) -> Result<(), String> {
    if score > max_score {
        return Err(format!("Score {} exceeds max score {}", score, max_score));
    }
    Ok(())
}

// Calculate percentage and pass/fail status (pass >= 60%)
fn grade_record(record: GradeRecord) -> Result {
    validate_score(record.score, record.max_score)?;
    let percentage = (record.score as f32 / record.max_score as f32) * 100.0;
    let pass_fail = if percentage >= 60.0 { "Pass" } else { "Fail" }.to_string();
    Ok(GradedRecord {
        student_id: record.student_id,
        assignment_name: record.assignment_name,
        score: record.score,
        max_score: record.max_score,
        percentage: (percentage * 100.0).round() / 100.0, // Round to 2 decimals
        pass_fail,
        submitted_at: record.submitted_at,
    })
}

fn main() -> Result<(), Box> {
    // Set up CLI arguments using clap
    let matches = Command::new("grade_csv")
        .version("1.0.0")
        .author("Student Grading Tool")
        .about("Grades student assignment CSVs and adds pass/fail status")
        .arg(
            Arg::new("input")
                .short('i')
                .long("input")
                .value_name("INPUT_CSV")
                .help("Input CSV file with student grades")
                .required(true),
        )
        .arg(
            Arg::new("output")
                .short('o')
                .long("output")
                .value_name("OUTPUT_CSV")
                .help("Output CSV file for graded results")
                .required(true),
        )
        .get_matches();

    let input_path = matches.get_one::("input").unwrap();
    let output_path = matches.get_one::("output").unwrap();

    // Open input file
    let input_file = File::open(input_path)?;
    let reader = BufReader::new(input_file);
    let mut csv_reader = ReaderBuilder::new()
        .has_headers(true)
        .from_reader(reader);

    // Open output file
    let output_file = File::create(output_path)?;
    let mut csv_writer = WriterBuilder::new()
        .has_headers(true)
        .from_writer(output_file);

    // Process each record
    for result in csv_reader.deserialize() {
        let record: GradeRecord = result?;
        match grade_record(record) {
            Ok(graded) => {
                csv_writer.serialize(graded)?;
            }
            Err(e) => {
                eprintln!("Failed to grade record: {}", e);
                continue;
            }
        }
    }

    csv_writer.flush()?;
    println!("Graded CSV written to {}", output_path);
    Ok(())
}

// Unit tests for grading logic
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_validate_score_valid() {
        assert!(validate_score(80, 100).is_ok());
    }

    #[test]
    fn test_validate_score_invalid() {
        assert!(validate_score(110, 100).is_err());
    }

    #[test]
    fn test_grade_record_pass() {
        let record = GradeRecord {
            student_id: "S001".to_string(),
            assignment_name: "Midterm".to_string(),
            score: 75,
            max_score: 100,
            submitted_at: "2026-03-15".to_string(),
        };
        let graded = grade_record(record).unwrap();
        assert_eq!(graded.pass_fail, "Pass");
        assert_eq!(graded.percentage, 75.0);
    }

    #[test]
    fn test_grade_record_fail() {
        let record = GradeRecord {
            student_id: "S002".to_string(),
            assignment_name: "Midterm".to_string(),
            score: 50,
            max_score: 100,
            submitted_at: "2026-03-15".to_string(),
        };
        let graded = grade_record(record).unwrap();
        assert_eq!(graded.pass_fail, "Fail");
        assert_eq!(graded.percentage, 50.0);
    }
}

# Context: Flask 3.0.0, SQLAlchemy 2.0.25, POST /api/courses, returns 201 on success
@app.route('/api/courses', methods=['POST'])
def add_course():
    # ... implementation

// Missing edge case test added manually
@Test
public void testSubmitEmptyFile() {
    MultipartFile emptyFile = new MockMultipartFile("file", "", "application/pdf", new byte[0]);
    ResponseEntity response = submitAssignment(1L, 1L, emptyFile);
    assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
}

{
    "codeium.telemetry.enabled": false,
    "github.copilot.telemetry.enabled": false,
    "github.copilot.editor.enableAutoCompletions": true
}