Prompt InFlow
EducationStudy GuidesIntermediate40 minSaves 1 hour

Criterion-Referenced Rubric for Programming Tasks

CS instructors need fair, evidence-anchored rubrics for grading programming assignments. This prompt generates a detailed rubric covering correctness, quality, testing, and documentation, ensuring consistent evaluation.

Generates a comprehensive, criterion-referenced rubric for computer science programming assignments. It includes four criteria (correctness, code quality, test coverage, documentation) with four performance levels, descriptive indicators, and weighting, designed for fair and consistent grading by CS instructors.

ChatGPTGeminiClaude

READY-TO-USE PROMPT

Copy Prompt

prompt.txt
As an educational assessment specialist.

### Context
Computer science instructors require a reliable and transparent method for evaluating programming assignments. The goal is to ensure fair, consistent, and pedagogically sound grading that clearly communicates expectations and feedback to students. This necessitates a detailed rubric that covers the core competencies of programming: functional correctness, maintainable code quality, thorough test coverage, and clear documentation. The rubric should guide instructors in applying consistent standards across all submissions for a given `{{assignment_name}}`, aligning with `{{learning_objectives}}`.

### Task
Generate a detailed assessment rubric for a programming assignment. The rubric must adhere to a 4x4 structure, featuring four distinct criteria and four performance levels for each criterion. Each performance level must include clear descriptors and specific, observable student-work indicators.

### Constraints
*   **Criteria**: The rubric must include precisely these four criteria:
    1.  Correctness
    2.  Code Quality
    3.  Test Coverage
    4.  Documentation
*   **Performance Levels**: For each criterion, define four distinct performance levels. Use clear, descriptive labels (e.g., Exemplary, Proficient, Developing, Beginning; or similar). Each level should clearly differentiate student performance.
*   **Descriptors**: For each criterion and performance level, provide a concise descriptor explaining what achievement at that level entails.
*   **Student-Work Indicators**: Crucially, include specific, observable examples of student work that would demonstrate achievement at each performance level for each criterion. These indicators should be concrete and actionable, helping instructors identify and students understand the expected output.
*   **Weighting Note**: Include a brief concluding statement acknowledging that criteria weighting may be adjusted based on assignment focus, but for this rubric, assume equal weighting initially.
*   **Tone**: The language throughout the rubric should be fair, criterion-referenced, and evidence-anchored, focusing on observable outcomes rather than subjective judgment.

### Output
Present the rubric in a clear, easy-to-read format, suitable for direct use or minor editing by an instructor. A table format is preferred for readability, with criteria as rows and performance levels as columns, or a similar structured list format.

Estimated results

DifficultyIntermediate
Setup time40 min
Time saved1 hour
Best modelsChatGPT, Gemini, Claude
Best audienceEducation

Editor's note

Why this prompt matters

Grading programming assignments presents a unique challenge for computer science instructors. Subjectivity can easily creep into evaluations, leading to inconsistencies and student frustration. Students, in turn, struggle to understand how their work is being assessed and what specific improvements are needed.

This workflow addresses these issues directly by generating a structured, criterion-referenced rubric. It's designed for instructors who need to provide clear, actionable feedback while maintaining fairness across a diverse set of student submissions. By focusing on observable behaviors and specific indicators of performance, the rubric helps standardize the grading process, making it transparent for both the grader and the student.

Reach for this tool when preparing to grade any programming assignment, from introductory scripting tasks to more complex software development projects. It ensures that core competencies like functional correctness, code quality, test coverage, and documentation are consistently evaluated, fostering a more equitable and educational assessment environment.

Anatomy

Prompt engineering breakdown

Role

This prompt assists computer science instructors by generating a comprehensive, criterion-referenced rubric for evaluating programming assignments, ensuring fair and consistent grading across core competencies.

Context

Computer science instructors require a reliable and transparent method for evaluating programming assignments. The goal is to ensure fair, consistent, and pedagogically sound grading that clearly communicates expectations and feedback to students. This necessitates a detailed rubric that covers the core competencies of programming: functional correctness, maintainable code quality, thorough test coverage, and clear documentation. The rubric should guide instructors in applying consistent standards across all submissions for a given `{{assignment_name}}`, aligning with `{{learning_objectives}}`.

Goal

Generate a detailed assessment rubric for a programming assignment. The rubric must adhere to a 4x4 structure, featuring four distinct criteria and four performance levels for each criterion. Each performance level must include clear descriptors and specific, observable student-work indicators.

Constraints

The rubric must include precisely four criteria: Correctness, Code Quality, Test Coverage, and Documentation. For each criterion, define four distinct performance levels with descriptive labels, concise descriptors, and specific, observable student-work indicators. A concluding statement acknowledging initial equal weighting, with an option to adjust, is required. The tone must be fair, criterion-referenced, and evidence-anchored.

Output format

Present the rubric in a clear, easy-to-read format, suitable for direct use or minor editing by an instructor. A table format is preferred for readability, with criteria as rows and performance levels as columns, or a similar structured list format.

Why this structure works

The explicit role priming as an 'educational assessment specialist' sets the model's perspective, guiding it to produce a pedagogically sound output. The detailed constraints on the 4x4 structure, specific criteria, and required elements like 'student-work indicators' ensure the model generates a comprehensive and usable rubric. Requesting a 'clear, easy-to-read format' further directs the model to prioritize the output's practical utility for instructors.

Pick your version

Prompt variations

BeginnerWorks with any model

For new instructors needing a simple rubric, less detail, or a quick draft to build upon, focusing on core elements without extensive pedagogical framing.

prompt.txt
You are a helpful assistant for teachers. Create a basic grading rubric for a programming assignment titled `{{assignment_topic}}`. The rubric needs 4 main areas: how well the code works (Correctness), how neat and readable the code is (Code Quality), if the tests cover everything (Test Coverage), and if the explanations are clear (Documentation). For each area, describe four levels of performance, like 'Great Job', 'Good', 'Needs Work', and 'Starting Out'. Include a simple description for each level and a couple of examples of what student work would look like at that level. The goal is to make grading clear for students and easy for you. Assume each area is equally important for now.
ProfessionalBest with chatgpt

When a detailed, pedagogically sound rubric is required that closely matches the main prompt's depth and structured approach for comprehensive evaluation.

prompt.txt
As an expert in educational assessment, develop a comprehensive, criterion-referenced rubric for evaluating a `{{programming_language}}` programming assignment named `{{assignment_title}}`. This rubric must support fair and transparent grading, aligning with `{{course_learning_objectives}}`. Structure the rubric with precisely four criteria: Correctness, Code Quality, Test Coverage, and Documentation. For each criterion, define four distinct performance levels (e.g., Exceeds Expectations, Meets Expectations, Partially Meets, Does Not Meet), providing both a clear descriptive statement and 2-3 specific, observable indicators of student work. The indicators should be concrete, focusing on measurable outcomes. Conclude with a note that criteria weighting can be adjusted per assignment, but assume equal weighting initially. Present in a clear, tabular or structured list format for ease of use by instructors.
Short VersionWorks with any model

For quick generation of core rubric elements, to be expanded manually, or for simple grading tasks where detailed descriptors are less critical.

prompt.txt
Generate a concise 4x4 rubric for a `{{project_type}}` programming assignment. The rubric must include Correctness, Code Quality, Test Coverage, and Documentation as the four criteria. For each criterion, define four performance levels (e.g., Excellent, Good, Fair, Poor) with brief, clear descriptors. Provide one or two key student-work indicators per level to guide quick assessment. This version is designed for rapid feedback and provides foundational insights for `{{student_group}}`. Assume an initial equal weighting for all criteria, with the understanding that instructors may adjust this based on the specific `{{assignment_focus}}`.
EnterpriseBest with claude

For institutions requiring rubrics that align with accreditation standards, departmental consistency, or formal assessment frameworks, emphasizing auditability and standardization.

prompt.txt
As a lead assessment architect, design an institutional-grade programming assignment rubric for `{{course_code}}` that ensures compliance with `{{institutional_assessment_policy}}`. This rubric must facilitate standardized evaluation across multiple instructors and sections, providing auditable evidence of student competency in `{{skill_domain}}`. The rubric must strictly adhere to a 4x4 structure, incorporating the following criteria: Correctness, Code Quality, Test Coverage, and Documentation. For each criterion, define four granular performance levels with explicit descriptors and specific, measurable student-work indicators that align with `{{department_standards}}`. Include a concluding statement on default equal weighting, while noting the process for requesting `{{custom_weighting_approval}}` for specific assignments. The output format should be suitable for integration into an `{{LMS_platform}}`.

What you'll get

Expected output

For a hypothetical assignment: "Implement a simple command-line utility to process a CSV file, calculate statistics (mean, median), and output results to a new file."

Rubric: CSV Data Processing Utility

| Criteria | Exemplary (4 points) | Proficient (3 points) | Developing (2 points) | Beginning (1 point) | | :------------- | :----------------------------------------------------- | :---------------------------------------------------------- | :-------------------------------------------------------- | :---------------------------------------------------------- | | Correctness | All specified functional requirements are met; handles all expected inputs, edge cases, and error conditions gracefully. Outputs are consistently accurate and formatted as specified. | Most functional requirements are met; handles typical inputs and some edge cases, but may have minor issues with complex scenarios or specific error conditions. Outputs are largely accurate. | Several functional requirements are met, but significant errors exist in handling typical inputs or producing accurate outputs. Fails to address most edge cases or error conditions. | Few functional requirements are met; code produces incorrect outputs for typical inputs or fails to run without significant intervention. Does not handle any edge cases or errors. | | Student-Work Indicators | - Program executes without errors for all test cases, including valid, invalid, and edge-case inputs. - Statistical calculations (mean, median) are consistently correct. - Output file format precisely matches specifications. | - Program executes with minor, non-blocking errors for some edge cases. - Statistical calculations are mostly correct, with minor discrepancies. - Output file format has minor deviations from specifications. | - Program crashes or produces incorrect results for typical valid inputs. - Significant errors in statistical calculations. - Output file format is inconsistent or incorrect. | - Program fails to compile or run. - Calculations are consistently incorrect or missing. - Output file is not generated or is entirely malformed. | | Code Quality | Code is exceptionally clear, concise, and well-structured. Follows established conventions consistently. Excellent use of meaningful variable names, functions, and comments. Highly maintainable and readable. | Code is generally clear, readable, and follows conventions. Good use of meaningful names and comments. Structure is logical, making it reasonably maintainable. | Code is difficult to read due to inconsistent formatting, poor naming conventions, or lack of logical structure. Comments are sparse or unhelpful. Minor refactoring would be required for maintenance. | Code is poorly organized, highly redundant, or excessively complex, making it very difficult to understand or modify. No consistent conventions, poor naming, and inadequate comments. | | Student-Work Indicators | - Code adheres to a consistent style guide (e.g., PEP 8 for Python). - Functions are small, single-purpose, and well-named. - Minimal code duplication. - Comprehensive and accurate inline comments explain complex logic. | - Code mostly adheres to style conventions. - Functions are generally well-defined, though some could be refactored. - Some minor code duplication present. - Comments are present for key sections but may lack detail. | - Inconsistent indentation or spacing. - Functions are overly long or handle multiple responsibilities. - Frequent code duplication. - Comments are missing in critical sections or are generic. | - Random indentation, inconsistent naming. - Monolithic functions or 'spaghetti code'. - Extensive copy-pasting of code. - No comments or comments that are misleading. | | Test Coverage | Comprehensive unit tests cover all critical functions and edge cases. Tests are well-organized, readable, and effectively demonstrate correctness and robustness. All tests pass successfully. | Good unit test coverage for most critical functions. Tests are generally well-written and pass, demonstrating functionality for typical cases. Some edge cases may be missed. | Limited unit tests, covering only basic functionality or a few positive cases. Tests may be poorly written, fail inconsistently, or not adequately verify correctness. | No unit tests provided, or tests are incomplete, fail consistently, or do not reflect the program's functionality. | | Student-Work Indicators | - Separate test file(s) with clear test cases for each function. - Tests for valid inputs, invalid inputs, and boundary conditions. - All tests pass consistently. - pytest coverage report shows high percentage (>90%). | - Test file(s) present with tests for main functions. - Tests cover typical use cases. - Most tests pass. - pytest coverage report shows moderate percentage (60-90%). | - Test file(s) present but sparse. - Only positive test cases; no edge cases. - Some tests fail or are poorly structured. - pytest coverage report shows low percentage (<60%). | - No test files. - Test files are empty or contain only boilerplate. - Tests are entirely incorrect or do not run. | | Documentation | Comprehensive documentation includes a clear README with installation, usage instructions, examples, and detailed explanations of program logic. All functions and modules are properly documented with docstrings. | Good documentation includes a README with clear installation and usage instructions. Key functions and modules have docstrings, adequately explaining their purpose. | Basic documentation exists, but it may be incomplete, unclear, or lack essential details (e.g., missing installation steps or usage examples). Docstrings are sparse or unhelpful. | No documentation (e.g., README.md is missing or empty). No docstrings or comments explaining program functionality. | | Student-Work Indicators | - README.md includes setup, execution, example commands, and expected output. - All public functions have clear docstrings explaining parameters, return values, and purpose. - Code comments explain complex algorithms. | - README.md covers setup and basic usage. - Most public functions have docstrings. - Some complex sections have inline comments. | - README.md is present but lacks details (e.g., no installation instructions). - Only a few docstrings are present, or they are very brief. - No comments explaining logic. | - No README.md file. - No docstrings or inline comments. - Project structure is not self-explanatory. |

*Note: Criteria weighting may be adjusted based on the specific focus of the assignment. For this rubric, assume equal weighting initially.*

Under the hood

Why this prompt works

This prompt generates a comprehensive rubric because it effectively employs several targeted prompt engineering techniques. First, role priming (As an educational assessment specialist) directs the model to adopt an expert persona, ensuring the output is authoritative and aligned with pedagogical best practices rather than generic content. This sets a professional tone and guides the model's understanding of assessment principles.

Crucially, explicit constraints are used extensively. The prompt mandates a precise 4x4 structure, specific criteria (Correctness, Code Quality, Test Coverage, Documentation), and the inclusion of both descriptors and observable student-work indicators for each performance level. This level of detail prevents the model from generating vague or incomplete rubrics and forces it to articulate concrete examples that instructors can use for evaluation. The requirement for a specific tone (fair, criterion-referenced, evidence-anchored) further refines the output.

Finally, the request for a structured output (table format preferred) ensures the rubric is presented in an immediately usable and readable format. This combination of expert role-play, rigorous constraints on content and structure, and clear formatting instructions yields a detailed, actionable, and pedagogically sound assessment tool, far superior to what a general request would produce.

Model fit

Best AI models for this prompt

ChatGPT

ChatGPT consistently delivers structured rubrics, effectively translating criteria and performance levels into descriptive text. While good at outlining the framework, the specificity of student-work indicators may sometimes require additional refinement to be highly granular. It is a solid choice for generating the initial structure and core descriptors. See the full ChatGPT hub for deeper guidance.

Claude

Claude excels at interpreting nuanced instructions and generating comprehensive, pedagogically sound content. It often produces the most detailed and thoughtfully articulated performance level descriptors and student-work indicators, making its output highly actionable for instructors. Claude is particularly strong when the prompt requires a high degree of textual coherence and educational insight. See the full Claude hub for deeper guidance.

Gemini

Gemini is capable of handling complex structured outputs and adhering closely to specific formatting requirements, making it reliable for generating the 4x4 rubric. It provides well-articulated differentiations between performance levels and can synthesize information effectively to create practical rubrics. Gemini's output often requires minimal editing for clarity and conciseness. See the full Gemini hub for deeper guidance.

When to use

  • To grade programming assignments that involve multiple dimensions like code correctness, structure, and documentation.
  • To provide detailed, actionable feedback to students beyond just a score.
  • To ensure consistent grading standards across multiple teaching assistants or instructors for the same assignment.
  • To clearly communicate expectations to students before they begin a programming project.
  • To assess specific learning objectives related to software engineering best practices, not just functional output.

When not to use

  • For very simple, foundational programming exercises focused solely on basic syntax or a single concept.
  • When a pass/fail or binary assessment is sufficient, and detailed feedback is not required.
  • If the primary goal is a quick evaluation of many small submissions, as detailed rubrics take more time to apply.
  • For non-programming assignments where the criteria (Correctness, Code Quality, Test Coverage, Documentation) are irrelevant.
  • In early-stage courses where students are not yet expected to meet professional code quality or documentation standards.

Get more from it

Pro tips

  • 1

    Before generating, explicitly define the 'Exemplary' level criteria for your specific course to ensure the output aligns with your highest expectations.

  • 2

    Review the generated rubric with TAs or fellow instructors before use to catch ambiguities and ensure consistent interpretation across graders.

  • 3

    When providing the `assignment_name` and `learning_objectives`, be precise; specific inputs yield a more tailored and immediately usable rubric.

  • 4

    Consider adding a 'Not Applicable' option or a zero-point column for criteria that some student submissions might completely omit, preventing grading confusion.

  • 5

    After an assignment, collect student feedback on the rubric's clarity to refine descriptors and indicators for future iterations, enhancing understanding.

Don't ship this

Common mistakes

  • ✗ Using vague `learning_objectives` in the prompt, resulting in generic rubric descriptors that lack specific relevance.

    Fix — Specify learning objectives with action verbs and quantifiable outcomes, such as 'Students will implement data structures correctly' for better rubric alignment.

  • ✗ Failing to adjust the rubric's weighting note for assignments that prioritize one criterion over others, leading to misaligned grading.

    Fix — Always modify the weighting note to reflect the actual emphasis of your assignment, ensuring students understand what is most important.

  • ✗ Not pre-defining the specific context of 'Correctness' (e.g., compile-time errors, runtime logic) for the model, leading to broad definitions.

    Fix — In your `Context` input, clarify what constitutes 'Correctness' for the given assignment type to guide the model's descriptor generation.

  • ✗ Accepting the default performance level labels without customizing them to your course's terminology or student understanding.

    Fix — Always review and rename performance levels (e.g., 'Mastery', 'Developing') to match your departmental standards or pedagogical approach.

  • ✗ Overlooking the need for a 'Not Submitted' or 'Minimal Effort' category, complicating grading for incomplete or absent work.

    Fix — Manually add a column or a specific policy note for submissions that do not meet even the 'Beginning' criteria, clarifying expectations.

People also ask

Frequently asked questions

Q.Can I add or remove criteria from the generated rubric?

The prompt is designed to strictly adhere to the four specified criteria. If you need different criteria, you will need to modify the prompt itself to list your desired categories before generation. This ensures the model focuses on your specific assessment needs.

Q.How do I adapt this rubric for an introductory programming course versus an advanced one?

Adjust the detail and sophistication of your learning_objectives in the prompt. For introductory courses, focus objectives on basic functionality and readability. For advanced courses, emphasize complex algorithms, efficiency, and advanced design patterns within the same criteria.

Q.Is it possible to assign different point values or weightings to each criterion?

The generated rubric includes a note acknowledging that weighting can be adjusted. You will need to manually assign specific point values or percentages to each criterion after the rubric is generated, based on your assignment's priorities. The model assumes equal weighting initially.

Q.What if a student's submission doesn't fit neatly into one performance level for a criterion?

Rubrics are guides, not rigid scales. Use your professional judgment. You can assign partial points between levels or provide specific qualitative feedback explaining why a submission falls between two descriptors. Focus on the evidence-anchored indicators.

Q.Can this rubric be used for peer grading or self-assessment?

Yes, its clear descriptors and student-work indicators make it suitable for peer grading or self-assessment. Students can use it to understand expectations, evaluate their own work, or provide constructive feedback to peers before final submission.

Version 1.0Last reviewed July 18, 2026
Reviewed by PromptInFlow Editorial Team