📄 CBSE Class 12 AI • Practical File

Project Report & Documentation

Artificial Intelligence (Subject Code 843) • Practical Project

🧠

BRAINILIS

AI-Powered Brain Training System with Adaptive Difficulty Engine & Cognitive Performance Analytics

Submitted by: Misbahul Basar — Class XII

School: Jawahar Navodaya Vidyalaya, Dakshin Dinajpur

Session: 2026 – 27

Guide Teacher: P. Sharma

iCertificate

This is to certify that Misbahul Basar of Class XII, Jawahar Navodaya Vidyalaya, Dakshin Dinajpur, has successfully completed the Artificial Intelligence practical project titled “BRAINILIS — AI-Powered Brain Training System” during the academic session 2026 – 27 under my guidance, in partial fulfilment of the CBSE Senior Secondary curriculum (Subject Code 843).

The project is genuine, original work carried out by the candidate.

Date: __________

___________________
P. Sharma (Guide Teacher)___________________
External Examiner

___________________
Principal (Seal)

iiAcknowledgement

I, Misbahul Basar, express my sincere gratitude to my guide teacher P. Sharma for constant guidance in AI concepts, project scoping and documentation; to the Principal and staff of Jawahar Navodaya Vidyalaya, Dakshin Dinajpur for lab facilities; to my parents and friends who play-tested every game; and to the CBSE AI curriculum designers and open-source community (Next.js, PostgreSQL, Drizzle) whose tools made this project possible.

Place: Dakshin Dinajpur • Date: __________ • (Misbahul Basar)

•Table of Contents

Introduction
Objectives
Problem Scoping (4Ws Canvas)
System Requirements
AI Project Cycle Mapping
AI Concepts Used
System Design & Modules
Dataset Description
Algorithm & Modelling
Implementation
Game Design Details
Testing
Results & Output
Conclusion
Future Scope
Bibliography
Appendix A — Viva Q&A
Appendix B — Demo Script

1Introduction

Brainilis is a fun brain-training game system designed to challenge mental abilities through a collection of short, interactive mini-games. It tests four core skills — Memory, Logic, Mathematics and Focus: remembering sequences, solving number puzzles, identifying patterns, reacting quickly and concentrating on details.

What makes Brainilis an Artificial Intelligence project rather than “just a game” is its AI layer: (a) an adaptive difficulty engine that personalises challenge level from performance data, (b) a cognitive analytics dashboard that converts raw gameplay into skill scores, charts and trends, and (c) a rule-based AI Coach that prescribes training. Every session is stored as structured data, so the system literally learns about the player over time.

Gameplay is simple and suited to quick 60–90 second sessions. Players beat previous scores, improve accuracy, and face increasingly difficult tasks — while the system tracks everything. The main goal: keep the mind active while having fun. Practising specific skills is genuinely useful, although better game scores do not mean overall IQ has increased — a limitation stated honestly throughout.

2Objectives

Build 6 playable mini-games covering 4 cognitive skills with fair scoring and timers.
Implement a rule-based adaptive difficulty engine (Easy → Medium → Hard → Expert) driven by accuracy + response time.
Collect a real, growing dataset of gameplay sessions in PostgreSQL.
Compute explainable cognitive scores (0–100) and a Brain Index with radar/trend visualisation.
Implement an AI Coach expert system giving personalised training recommendations.
Publish the system as a working website anyone can play, plus a printable CBSE-format report.

3Problem Scoping — 4Ws Canvas

The CBSE AI Project Cycle begins with scoping. Our 4Ws canvas:

W	Analysis
Who (stakeholders)?	Students (players), teachers/examiners (evaluators), parents (observers). Primary user: Class 11–12 students wanting fun brain exercise.
What (problem)?	Brain-training apps are either boring, one-size-fits-all, or give no insight. Fixed difficulty bores strong players and frustrates weak ones; scores without analysis don't guide improvement.
Where (context)?	School computer labs, home mobiles/desktops, short free periods. Must run in a browser, need no install, work on low-end devices.
Why (value)?	Personalised difficulty keeps players in the 'flow zone'; analytics + coaching convert play into deliberate practice; the project itself demonstrates the full AI lifecycle for the CBSE practical.

Problem statement: “How can an AI system personalise brain-training difficulty and convert gameplay data into actionable cognitive insights for students?”

4System Requirements

Category	Requirement
Hardware (dev)	Any dual-core PC, 4 GB RAM, internet (project runs in browser; server can be cloud-hosted).
Hardware (user)	Smartphone / tablet / PC with a modern browser. No installation needed.
Software (stack)	Next.js 16 + React 19 + TypeScript (UI + API), Tailwind CSS (design), PostgreSQL 16 (database), Drizzle ORM (data access), Node.js 20 runtime.
Data	Self-generating dataset: each completed game appends one row to game_sessions. No external dataset download needed.
Deployment	Published website (Vercel-compatible Next.js build) + managed PostgreSQL. ‘npm run build’ verified.

5AI Project Cycle Mapping

Stage	How Brainilis implements it
1. Problem Scoping	4Ws canvas (Section 3) → crisp problem statement + success criteria (playable, adaptive, analytical, published).
2. Data Acquisition	Automatic: every session POSTs score, accuracy, avg response ms, max level, duration, difficulty to /api/scores → PostgreSQL.
3. Data Exploration	Dashboard: Brain Index ring, 4-skill radar, per-skill bars, score trend line, leaderboard, recent-sessions table.
4. Modelling	Rule-based expert system: adaptDifficulty() + cognitiveScore() + aiCoach() in src/lib/ai-engine.ts. Deterministic & explainable.
5. Evaluation	Rule-verification tests, accuracy/Brain-Index improvement tracking, functional + boundary + UX testing (Section 12).

6AI Concepts Used (CBSE Syllabus Links)

Rule-Based AI / Expert Systems: IF-THEN rules encoding human expertise (coach knowledge: “accuracy ≥ 85% ⇒ promote”). Transparent, needs no training data.
Adaptive / Personalised Systems: difficulty state machine per game per player (Easy → Medium → Hard → Expert).
Data Literacy: structured dataset design, features vs labels (skill ≈ label), aggregation (best/avg), visualisation.
Human–AI Interaction: AI verdict messages, coach tips with priority levels, difficulty badges — AI decisions are always shown, never hidden.
AI Ethics: no personal data beyond display name, no medical/IQ claims, supportive adaptation (never punishes strugglers), honest limitations.
Evaluation Thinking: defining “does the AI work?” via rule checks + outcome metrics + latency.

7System Design & Modules

Architecture (3 tiers): (1) Client — 6 game UIs + dashboard + report pages (React). (2) API — /api/scores (write/read dataset), /api/stats (aggregations, leaderboard, trends), /api/ai-coach (runs expert system). (3) Data — PostgreSQL via Drizzle ORM.

Table	Columns
players	id (PK), name UNIQUE, created_at
game_sessions	id (PK), player_name, game_id, skill, score, accuracy, avg_response_ms, max_level, duration_sec, difficulty, played_at

Modules: Game Engine (6 games + GameShell wrapper handling intro/result/save), AI Engine (src/lib/ai-engine.ts), Analytics (dashboard charts in SVG), Documentation (this report + certificate pages).

Data flow: Play → finish → result computed locally → adaptDifficulty() picks next level → POST /api/scores → dashboard/leaderboard/coach read it back via GET.

8Dataset Description

Each row = one completed session. Feature table:

Feature	Type	Example	Used for
player_name	text	Misbahul	Personalisation, leaderboard
game_id	category (6)	math-sprint	Per-game analysis
skill	label (4)	mathematics	Skill scores, radar
score	integer	1240	Trend, leaderboard
accuracy	0–100 %	87.5	Difficulty rules, scoring
avg_response_ms	integer	1830	Speed rules, diagnosis
max_level	integer	5	Mastery bonus
duration_sec	integer	60	Session stats
difficulty	category (4)	hard	Adaptation audit trail

The dataset grows with use — a living dataset. The live counter on the home page shows its current size.

9Algorithm & Modelling

A. Adaptive Difficulty — adaptDifficulty(current, accuracy, avgMs)

IF accuracy ≥ 85 AND avgMs ≤ fast_threshold AND level < EXPERT:
    RETURN level + 1   // "Excellent run — raising difficulty"
ELSE IF (accuracy < 55 OR avgMs > 2.2 × threshold) AND level > EASY:
    RETURN level - 1   // "Challenging run — rebuilding confidence"
ELSE:
    RETURN level        // "Steady — consolidation"

B. Cognitive Score (per skill, 0–100)

score = 0.40 × best_accuracy + 0.30 × mean_accuracy
      + min(best_level × 4, 20)        // mastery
      + min(sessions / 5, 1) × 10       // consistency
      + speed_bonus(0–15) − 10          // baseline shift
Brain_Index = mean(memory, logic, mathematics, focus)

C. AI Coach — aiCoach(sessions): priority-ordered rules

IF no sessions → “build baseline: play each game once”.
IF weakest skill < 40 → HIGH priority targeted training plan + deep link.
IF strongest ≥ 55 → MEDIUM “push to Expert” tip.
IF recent accuracy < 60 AND fast → HIGH “slow down” diagnosis (and the inverse for slow-but-accurate).
Consistency + rematch tips fill remaining slots (max 4).

Complexity is O(n) over a player's sessions (n ≤ 200 fetched) — instant even on phones.

10Implementation

Layer	Technology
UI + game logic	Next.js App Router + React 19 + TypeScript + Tailwind CSS
Charts	Hand-built SVG (radar, ring, trend) — zero chart-library dependency
Backend API	Next.js Route Handlers: /api/scores, /api/stats, /api/ai-coach
Database	PostgreSQL + Drizzle ORM (schema in src/db/schema.ts)
AI model	src/lib/ai-engine.ts (~150 lines, pure functions — easily testable)

src/
├── app/
│   ├── page.tsx                 → home (hero, games, AI showcase)
│   ├── play/[gameId]/page.tsx   → game player route
│   ├── dashboard/page.tsx       → analytics + AI coach
│   ├── documentation/page.tsx   → this report (printable)
│   ├── certificate/page.tsx     → printable certificate
│   └── api/scores|stats|ai-coach→ backend endpoints
├── components/games/            → GameShell + 6 games + runner
├── lib/games.ts                 → game catalogue + project info
├── lib/ai-engine.ts             → ★ THE AI MODEL (rules + scoring)
└── db/schema.ts                 → players + game_sessions tables

11Game Design Details

Game	Skill	Duration	Scoring
Sequence Memory 🟪	Memory	~90 s	chain_length × 10 per round; 3 strikes end run
Math Sprint ⚡	Mathematics	60 s	10 × streak multiplier (×1–×5); wrong resets streak
Stroop Focus 🎨	Focus	60 s	+10 + speed bonus (≤1s:+10, ≤2s:+5); wrong −5
Pattern Logic 🔍	Logic	90 s	tier × 10; 2-in-a-row promotes Arithmetic→Geometric→Advanced
Reaction Rush 🚦	Focus	~60 s	2000 − avg_ms × 2.2 over 8 rounds; false starts hurt accuracy
Odd One Out 👁️	Logic	75 s	level × 10; grid 3×3→8×8; wrong tap −2 s

Each game shows a How-to-Play intro, live HUD, and an AI-verdict result screen with next-difficulty routing — consistent UX across all six.

12Testing

#	Test case	Expected	Result
T1	Complete each game start→finish	Result screen + saved to DB	PASS
T2	High-accuracy session (≥85%)	Difficulty promotes one step	PASS
T3	Low-accuracy session (<55%)	Difficulty demotes one step	PASS
T4	Empty/guest player name	Defaults to Guest, still saves	PASS
T5	Timer expiry mid-game	Auto-finish with partial score	PASS
T6	False-start tapping in Reaction Rush	Penalty, round re-arms	PASS
T7	Dashboard with 0 sessions	Friendly empty state, no crash	PASS
T8	Mobile (360px) + desktop layouts	No overflow, tappable	PASS
T9	Report + certificate print	Clean white print/PDF	PASS
T10	Production build (npm run build)	Zero type/build errors	PASS

13Results & Output

Home page: hero, live dataset counters, 4 skill cards, 6 game cards, AI-engine showcase, developer credit banner.
Game screens: intro (rules + current AI difficulty) → live play with HUD → result (score, grade, accuracy, AI verdict, next difficulty).
Dashboard: Brain Index ring, cognitive radar, skill bars, AI Coach tips, score trend, leaderboard, recent sessions.
Sample outcome: a new player scoring ~50% on Math Sprint sees difficulty drop to Easy; after practice at 85%+, it climbs to Hard/Expert while Brain Index rises — the adaptation loop working end-to-end.
Tip for the file: attach 4–6 screenshots (home, one game mid-play, result screen, dashboard, this report, certificate) printed from the live site.

14Conclusion

Brainilis meets every objective: six genuinely fun games, a working adaptive AI, a real growing dataset, explainable analytics, a coaching expert system, a published website and complete documentation. Building it taught the full AI project cycle — scoping, data, modelling, evaluation — plus full-stack development and honest reporting of limitations (notably: game scores measure practised skill, not IQ). The rule-based approach proved that AI can be simple, transparent and immediately useful — an ideal foundation before advancing to machine learning.

15Future Scope

ML upgrade: train a difficulty/score predictor (decision tree / logistic regression) on the accumulated dataset; compare vs rules.
Accounts & cloud sync: login, cross-device profiles, class-level teacher dashboard.
More games: verbal memory, N-back, chess-tactic puzzles, typing focus tests.
Multiplayer: live challenges, tournaments, school leaderboards.
Research: longitudinal study — does 4 weeks of play improve focus-task scores? (with consent + ethics review).

16Bibliography

CBSE — Artificial Intelligence Curriculum, Senior Secondary (Subject Code 843), AI Project Cycle.
Stroop, J. R. (1935) — Studies of interference in serial verbal reactions (the Stroop effect).
Next.js, React, Tailwind CSS, PostgreSQL, Drizzle ORM — official documentation.
Human reaction-time benchmarks literature (≈150–300 ms simple response norms).
NCERT / CBSE AI practical guidelines for Class 12 project-work and viva-voce.

AAppendix A — Viva-Voce Q&A (must prepare)

Q1. What is your project and why did you choose it?

Brainilis is an AI-powered brain-training game system. I chose it because it combines something fun and useful — short cognitive games — with real, demonstrable AI: adaptive difficulty, performance analytics and a rule-based AI coach. It also generates its own dataset from gameplay.

Q2. Which AI domain does your project belong to?

Primarily Data + Rule-based AI. Gameplay produces structured data (score, accuracy, speed, level), and a rule-based expert system reasons over that data to adapt difficulty and give coaching advice. The dashboard is data visualisation, a key AI skill.

Q3. Explain the AI Project Cycle stages in your project.

1) Problem Scoping — students need engaging brain exercise and personalised difficulty (4Ws canvas in report). 2) Data Acquisition — gameplay sessions stored in PostgreSQL. 3) Data Exploration — dashboard charts reveal strengths/weaknesses. 4) Modelling — rule-based expert system for difficulty + scoring formulas. 5) Evaluation — accuracy improvement, Brain Index growth, and testing.

Q4. What is a rule-based AI / expert system? Where is it in your project?

A rule-based AI makes decisions using human-written IF-THEN rules instead of learning from huge data. In Brainilis: adaptDifficulty() (IF accuracy ≥ 85% AND fast THEN level up), the cognitive scoring formula, and the AI Coach tips are all expert-system rules — in src/lib/ai-engine.ts.

Q5. Why rule-based AI instead of machine learning?

Three reasons: 1) The CBSE syllabus explicitly teaches rule-based AI; 2) Our dataset starts small, and rules work from day one with zero training data; 3) Rules are 100% explainable — I can tell the examiner exactly why the AI made each decision, unlike a black-box model. The architecture allows plugging in an ML model later.

Q6. How does your adaptive difficulty algorithm work?

After each session it reads accuracy and average response time. IF accuracy ≥ 85% and responses are fast, difficulty goes up one step (Easy→Medium→Hard→Expert). IF accuracy < 55% or responses are very slow, it steps down. Otherwise it holds — consolidation before progression.

Q7. What data does your project collect? Describe the dataset.

Every completed game saves one row: player name, game, skill, score, accuracy %, average response ms, max level, duration, difficulty and timestamp. This is a labelled, structured dataset — the skill column is effectively the label for analysis.

Q8. How is the Brain Index / cognitive score calculated?

Per skill: best accuracy × 0.4 + average accuracy × 0.3 + level bonus (up to 20) + consistency bonus for 5+ sessions + speed bonus − baseline. Brain Index is the mean of the four skill scores. It rewards accuracy first, then mastery, consistency and speed.

Q9. What is the difference between your AI Coach and a chatbot?

The AI Coach is a deterministic expert system — same data always gives the same advice, and every tip traces to a visible rule (e.g., weakest skill < 40 → priority training plan). A chatbot generates free text probabilistically. Mine is safer, testable and fully explainable.

Q10. Which games test which skills, and why?

Sequence Memory + Number-style recall → Memory. Pattern Logic + Odd One Out → Logic. Math Sprint → Mathematics. Stroop Focus + Reaction Rush → Focus/attention. Stroop is a real psychology test (ink vs word conflict); reaction time is benchmarked against human norms (150–500 ms).

Q11. What is the Stroop effect?

The delay/interference when a word's meaning conflicts with its ink colour (e.g., the word RED printed in blue). Naming the ink colour requires focused attention to suppress the automatic reading response — that's why it's a classic focus test.

Q12. What technologies did you use and why?

Next.js (React) for the game UI and website, TypeScript for safe code, Tailwind CSS for design, PostgreSQL + Drizzle ORM for the dataset, and Vercel-style hosting so the project is published and demoable live. One language (TypeScript) for frontend, backend and AI logic.

Q13. Explain your database schema.

Two tables: players(id, name, created_at) and game_sessions(id, player_name, game_id, skill, score, accuracy, avg_response_ms, max_level, duration_sec, difficulty, played_at). One row per session — simple, normalised enough for the purpose, and queryable for analytics and leaderboards.

Q14. How did you test your project?

Functional testing (each game playable start-to-finish), boundary testing (empty name, zero scores, timer expiry), AI-rule testing (high accuracy must raise difficulty; low must lower it), responsive testing on mobile/desktop, and print testing of this report. Details in the Testing section.

Q15. How do you evaluate whether your AI works?

Rule verification (difficulty moves in the correct direction), outcome metrics (accuracy and Brain Index improve over sessions for a regular player), and latency (adaptation is instant, O(1)). Future: A/B test adaptive vs fixed difficulty groups.

Q16. What are the limitations of your project?

Rules are hand-tuned, not learned; difficulty adapts between sessions, not mid-game; no user accounts/passwords (single-device names); scores measure game skill, not IQ. All are listed honestly with future-scope fixes.

Q17. What is your future scope?

ML difficulty predictor trained on the growing dataset, login accounts with cloud sync, more games (verbal memory, chess puzzles), multiplayer challenges, and longitudinal studies of score improvement over months.

Q18. Is this project ethically safe?

Yes — no personal data beyond a display name, no passwords, no tracking, no medical claims (we explicitly state scores ≠ IQ), difficulty adapts supportively (never punishes struggling players by making things harder).

Q19. Show me your source code structure.

src/lib/games.ts (game catalogue), src/lib/ai-engine.ts (the AI model — show this first!), src/components/games/ (game logic), src/app/api/ (scores, stats, ai-coach endpoints), src/db/schema.ts (tables), src/app/dashboard + documentation + certificate (pages).

Q20. What did YOU learn from this project?

The full AI project cycle hands-on: scoping a problem, designing data collection, writing an explainable model, visualising data, and evaluating fairly — plus full-stack web development and technical documentation. Most importantly: AI doesn't have to be a black box to be useful.

BAppendix B — Examiner Demo Script (5 minutes)

0:00–0:30 — Open home page: “This is Brainilis, my AI brain-training system — 6 games, 4 skills.”
0:30–2:00 — Play Math Sprint live: “Watch the streak multiplier and adaptive problems.” Finish → show AI verdict + difficulty change.
2:00–3:00 — Open Dashboard: “Every run becomes data — Brain Index, radar, trend, leaderboard.”
3:00–4:00 — Show AI Coach tips: “A rule-based expert system prescribes training — deterministic and explainable.”
4:00–4:30 — Show code: open src/lib/ai-engine.ts, read the 3-line difficulty rule aloud.
4:30–5:00 — Close: “Report, certificate and viva prep are built in. Scores train skills — I make no IQ claims. Thank you.”

Continue to printable Certificate →

Handwritten-file tip: copy sections 1–16 into your practical file in your own handwriting, paste printed screenshots, and keep this page open on exam day for the demo + viva.