AI for Question Papers: Create Balanced Exams with AI

I need to prepare a question paper
for Class X Computer Science.

Use only the following syllabus:

[SYLLABUS]

Create a topic-wise assessment
blueprint.

For each topic include:
- Key concepts
- Learning objectives
- Suggested question types
- Suggested marks
- Possible cognitive levels

Do not add topics outside
the supplied syllabus.

Clearly identify any information
that cannot be determined from
the syllabus alone.

Using this syllabus:

[SYLLABUS]

Create a question-paper blueprint.

Total Marks:
[MARKS]

Duration:
[DURATION]

Required distribution:
[REQUIREMENTS]

Include columns for:

Topic |
Learning Objective |
Question Type |
Cognitive Level |
Difficulty |
Marks |
Question Count

Do not invent official assessment
requirements that have not been provided.

Create a question bank for Class X
Computer Science.

Syllabus:
[SYLLABUS]

Generate:

20 one-mark questions
15 two-mark questions
10 three-mark questions
5 four-mark questions

Include a mixture of:
- Recall
- Understanding
- Application
- Analysis

For every question include:
- Topic
- Marks
- Cognitive level
- Difficulty

Do not generate the final paper yet.

Create 15 questions on
Python functions for Class XI.

Distribution:
5 easy
7 moderate
3 challenging

Question types:
- Conceptual
- Output prediction
- Debugging
- Programming

For each question provide:
- Marks
- Difficulty
- Cognitive level
- Expected answer

Create 15 MCQs for Class X
Computer Science.

Topics:
[TOPICS]

Requirements:
- Four options per question
- One intended correct answer
- Plausible distractors
- No ambiguous wording
- No repeated concepts

Provide:
Question |
Options |
Correct Answer |
Topic |
Cognitive Level |
Difficulty

Create two case-based questions
for Class X Computer Science.

Topics:
[TOPICS]

Each case should:
- Present a realistic scenario.
- Contain sufficient information
  to answer the questions.
- Include 4 sub-questions.
- Test application and analysis.
- Avoid requiring information
  not provided in the case.

Include marks and answer points.

Create competency-oriented questions
for Class X on cybersecurity.

Create:
3 application questions
2 analysis questions
2 decision-making questions

Use realistic school, home,
or digital-life scenarios.

For each question provide:
- Marks
- Expected competencies
- Answer points
- Possible misconception

Create five Python programming
questions for Class XI.

Topics:
Functions
Parameters
Arguments
Return values

Difficulty:
2 easy
2 moderate
1 challenging

For each question provide:
- Problem statement
- Marks
- Expected learning objective
- Reference solution
- Test cases

Verify that each solution
matches the problem statement.

Create eight SQL questions
for Class XII.

Database structure:

[SCHEMA]

Include:
- SELECT
- WHERE
- ORDER BY
- Aggregate functions
- GROUP BY

For each question provide:
- SQL task
- Marks
- Expected query
- Expected result where possible

Do not use SQL features outside
the specified syllabus.

Review these questions:

[QUESTIONS]

Classify each as:
Easy / Moderate / Challenging

Consider:
- Required prior knowledge
- Number of reasoning steps
- Cognitive demand
- Complexity of the task

Give a short justification for
each classification.

Do not classify a question as
challenging merely because it
contains lengthy text.

Classify these questions according
to their primary cognitive demand.

[QUESTIONS]

Use:
- Remember
- Understand
- Apply
- Analyze
- Evaluate
- Create

For each question provide:
Question Number |
Cognitive Level |
Reason

If a question does not clearly
fit one level, explain why.

Review this question-paper blueprint.

[BLUEPRINT]

Check whether the planned paper
has an appropriate balance of:

- Topics
- Marks
- Question types
- Cognitive levels
- Difficulty

Identify:
1. Overrepresented areas
2. Underrepresented areas
3. Possible gaps
4. Suggested adjustments

Do not change the blueprint
without explaining the reason.

Create a draft question paper
using the following approved blueprint.

[BLUEPRINT]

Question Bank:
[QUESTION BANK]

Requirements:
- Total Marks: [MARKS]
- Duration: [DURATION]
- Follow the blueprint.
- Cover all required topics.
- Maintain the specified question
  distribution.
- Use clear instructions.
- Avoid duplicate questions.
- Maintain appropriate difficulty.

Do not invent questions outside
the approved syllabus.

At the end provide a paper-audit
summary showing:

Topic Coverage |
Marks |
Question Count |
Cognitive Distribution |
Difficulty Distribution

Draft clear examination instructions
for this question paper.

[QUESTION PAPER STRUCTURE]

Include only instructions that
are supported by the examination
requirements supplied below.

[REQUIREMENTS]

Do not invent rules about:
- Calculators
- Reading time
- Internal choices
- Answer-book format
- Electronic devices

unless explicitly provided.

Review these pairs of questions
for internal choice.

[QUESTION PAIRS]

Check whether each pair has:
- Same marks
- Similar difficulty
- Comparable cognitive demand
- Similar syllabus coverage
- Comparable expected workload

Return:

Pair | Balanced? | Issue |
Recommended Revision

Compare these two questions.

Question A:
[QUESTION A]

Question B:
[QUESTION B]

Determine whether they are
equivalent in:

- Learning objective
- Marks
- Difficulty
- Cognitive level
- Required knowledge
- Expected time

Return:
Equivalent / Not Equivalent

Explain any imbalance.

Create three equivalent question
paper sets.

Approved blueprint:
[BLUEPRINT]

Question bank:
[QUESTION BANK]

Requirements:
- Same total marks
- Same duration
- Same topic coverage
- Same question distribution
- Similar difficulty
- Similar cognitive distribution
- Different question wording,
  data, examples, or scenarios

Do not create one set that is
noticeably easier or harder
than the others.

Provide a comparison audit
after generating the sets.

Reorder the following questions
without changing their content.

[QUESTIONS]

Requirements:
- Preserve section structure.
- Preserve marks.
- Preserve question types.
- Avoid placing highly similar
  questions next to each other.
- Keep the difficulty progression
  reasonable.

Return the revised numbering.

Check this question paper
for duplicate or near-duplicate
questions.

[QUESTION PAPER]

Identify:
- Exact duplicates
- Conceptual duplicates
- Questions testing the same
  skill repeatedly
- Questions with substantially
  overlapping wording

Return:
Question Numbers |
Type of Duplication |
Recommendation

Review this question paper
for ambiguous questions.

[QUESTION PAPER]

Identify questions where:
- More than one answer may be valid.
- The wording permits multiple interpretations.
- Required information is missing.
- An option is technically defensible.
- A diagram or data reference is unclear.

For each issue provide:
Question Number |
Problem |
Why It Is Ambiguous |
Suggested Revision

Create a draft answer key for
the following question paper.

[QUESTION PAPER]

For every question include:
- Correct answer
- Expected answer points
- Marks

For MCQs:
Provide the correct option.

For programming:
Provide the expected output
or a correct reference solution.

For open-ended questions:
Identify acceptable answer points.

Flag questions where more than
one answer may reasonably be accepted.

Create a detailed marking scheme
for this question paper.

[QUESTION PAPER]

For each question provide:
- Maximum marks
- Expected answer elements
- Marks for each element
- Alternative acceptable responses
  where appropriate

Ensure:
- Marks add correctly.
- No marks are assigned twice.
- The marking scheme matches
  the question.

Flag any question for which
a reliable marking scheme cannot
be created from the question alone.

Create a marking scheme for
these Python programming questions.

[QUESTIONS]

For each question consider:
- Correct approach
- Syntax
- Logic
- Output
- Edge cases where relevant

Do not award marks solely for
matching a reference solution.

Allow equivalent correct approaches
where appropriate.

Validate this question paper.

[QUESTION PAPER]

Check:

1. Total marks
2. Question numbering
3. Section numbering
4. Topic coverage
5. Marks distribution
6. Cognitive distribution
7. Difficulty distribution
8. Question duplication
9. Question clarity
10. Internal choices
11. Answerability
12. Answer-key consistency
13. Programming/code correctness
14. Instructions
15. Time feasibility

Return:

Criterion | Status | Issue |
Recommended Action

Do not assume the paper is correct
because it was generated from
a blueprint.

Audit the marks in this paper.

[QUESTION PAPER]

Calculate:
- Marks per section
- Total marks
- Marks represented by internal
  choices
- Number of questions

Check whether the displayed
total matches the actual total.

Show the calculation explicitly.

Estimate whether this question
paper can reasonably be completed
within [DURATION].

[QUESTION PAPER]

Consider:
- Reading time
- Thinking time
- Writing time
- Programming time
- Case-study interpretation
- Diagram or table analysis

Identify questions or sections
that may consume significant time.

Return:
Section | Estimated Time |
Reason

Clearly label estimates as
approximations rather than
measured timings.

Proofread this question paper.

[QUESTION PAPER]

Check:
- Grammar
- Spelling
- Punctuation
- Sentence clarity
- Consistent terminology
- Unnecessary complexity

Do not change the academic
meaning of any question.

Return:
Original | Suggested Revision | Reason

Review the language of this
Class VIII question paper.

[QUESTION PAPER]

Check whether:
- Instructions are clear.
- Vocabulary is age-appropriate.
- Sentences are unnecessarily complex.
- Technical terms are used correctly.

Do not reduce the academic
difficulty of the questions.

Evaluate each question in this
paper.

[QUESTION PAPER]

For each question assess:

- Relevance
- Clarity
- Accuracy
- Cognitive demand
- Difficulty
- Syllabus alignment
- Answerability

Return:

Question | Strength | Concern |
Recommended Action

Review the MCQs in this paper.

[MCQS]

For each question check:
- Exactly one intended correct answer
- Plausibility of distractors
- Similarity of option structure
- Unintended clues
- Grammar consistency
- Option length bias
- Technical accuracy

Flag any question requiring
revision.

Review this case-based question.

[CASE]

Check whether:
- The case contains sufficient information.
- Every question can be answered
  from the case and permitted knowledge.
- The questions are not repetitive.
- Marks are appropriate.
- The expected answers are defensible.
- The case does not contain
  contradictory information.

List all issues found.

Review this data-based question.

[QUESTION AND DATA]

Check:
- Whether the data is internally consistent.
- Whether every question can be
  answered from the supplied data.
- Whether calculations are correct.
- Whether units are clearly stated.
- Whether the expected answers
  are unambiguous.

Show any calculations used
to verify the question.

Review the following Python
question for examination use.

[QUESTION AND CODE]

Check:
- Syntax
- Logic
- Expected output
- Variable values
- Indentation
- Edge cases
- Question clarity

Trace the code step by step.

Then provide:
Final Output |
Explanation |
Potential Issue |
Recommendation

Do not assume the supplied
expected output is correct.

Verify this SQL examination question.

Database schema:
[SCHEMA]

Question:
[QUESTION]

Expected query:
[QUERY]

Check:
- SQL syntax
- Table and column names
- Logical correctness
- Compatibility with the
  specified SQL level
- Whether the query satisfies
  the question

Identify alternative valid
queries where appropriate.

Compare these two question papers.

Paper A:
[PAPER A]

Paper B:
[PAPER B]

Compare:
- Topic coverage
- Marks distribution
- Question types
- Cognitive levels
- Difficulty
- Programming load
- Case-study load
- Expected workload

Identify any major imbalance.

Audit these three examination sets.

[SET A]
[SET B]
[SET C]

Determine whether the sets are
reasonably equivalent in:

- Total marks
- Topic coverage
- Question types
- Cognitive demand
- Difficulty
- Expected completion time
- Programming complexity

Return a comparison table.

Flag any significant imbalance.

Format the following approved
question paper.

[QUESTION PAPER]

Create a clean examination layout
containing:

- Examination title
- Class
- Subject
- Date
- Time
- Maximum Marks
- General Instructions
- Sections
- Question numbering
- Marks for each question
- Internal choices

Do not modify the academic
content or marks.

Convert this finalized question
paper into a teacher-only answer key.

[QUESTION PAPER]

Preserve:
- Question numbering
- Section numbering
- Marks

Add:
- Correct answers
- Expected answer points
- Marking scheme
- Reference code
- Expected outputs

Clearly separate the answer key
from the student question paper.

Create an examination
documentation summary for this paper.

[QUESTION PAPER]
[BLUEPRINT]

Include:
- Syllabus coverage
- Topic-wise marks
- Question-type distribution
- Cognitive-level distribution
- Difficulty distribution
- Total marks
- Number of questions
- Internal choices
- Verification status

Present the result as a
teacher/examination-review table.

Act as an experienced examination
paper designer.

Class:
[CLASS]

Subject:
[SUBJECT]

Examination:
[EXAMINATION NAME]

Syllabus:
[SYLLABUS]

Total Marks:
[MARKS]

Duration:
[DURATION]

Approved Blueprint:
[BLUEPRINT]

Additional Requirements:
[REQUIREMENTS]

Create a draft question paper.

Requirements:

1. Stay strictly within the supplied syllabus.
2. Follow the approved blueprint.
3. Maintain the specified marks distribution.
4. Include the required question types.
5. Maintain the required cognitive distribution.
6. Maintain the required difficulty distribution.
7. Avoid duplicate questions.
8. Avoid ambiguous questions.
9. Use clear age-appropriate language.
10. Ensure every question is answerable.
11. Keep internal choices reasonably equivalent.
12. Ensure programming and numerical questions are internally consistent.

After the paper, provide an audit table:

Topic Coverage |
Marks Distribution |
Question Count |
Cognitive Distribution |
Difficulty Distribution |
Question-Type Distribution

Do not claim compliance with
any official board pattern unless
that pattern has been explicitly
provided in the prompt.

This is a draft for teacher review,
not a final examination paper.

Act as an independent examination
quality reviewer.

Review this question paper.

[QUESTION PAPER]

Approved Blueprint:
[BLUEPRINT]

Check:

1. Syllabus alignment
2. Topic coverage
3. Learning-objective alignment
4. Marks distribution
5. Question-type distribution
6. Cognitive levels
7. Difficulty
8. Question clarity
9. Ambiguity
10. Duplication
11. Internal-choice equivalence
12. Answerability
13. Programming/code correctness
14. Numerical accuracy
15. Answer-key consistency
16. Time feasibility

Return:

Criterion | Status | Evidence |
Recommended Action

Then provide:

Critical Issues
Major Issues
Minor Issues
Ready for Teacher Verification?

Do not approve the paper solely
because it follows the blueprint.

Create three equivalent
question-paper sets.

Approved Blueprint:
[BLUEPRINT]

Base Question Bank:
[QUESTION BANK]

Requirements:

- Same total marks
- Same duration
- Same syllabus coverage
- Same number of questions
- Same question types
- Similar cognitive distribution
- Similar difficulty
- Similar expected workload

Use different:
- Data values
- Scenarios
- Examples
- Question wording

Do not make one set easier
or harder than another.

After generating the sets,
create an equivalence audit:

Criterion | Set A | Set B | Set C |
Balance Status

Flag any question that may
create an unintended difference
in difficulty.

Create a detailed teacher answer key
for this question paper.

[QUESTION PAPER]

For each question provide:

- Correct answer
- Expected answer points
- Marks
- Alternative acceptable answers
  where appropriate

For programming questions:
- Reference solution
- Expected output
- Important logic points

For numerical questions:
- Formula
- Working
- Final answer

Flag:
- Ambiguous questions
- Multiple valid answers
- Questions requiring
  teacher judgment

Do not assume the question
is correct merely because
an answer can be generated.