Curriculum Truth Ledger

This is a submission for the Sanity Challenge, Path Two: Vibe-Code Something Strange

I built Curriculum Truth Ledger, an evidence-first application for recording curriculum claims, connecting them to official sources, and presenting precise human-reviewed evidence.

Curriculum statements are often repeated without showing where they came from. I wanted to create something more transparent: a ledger where every conclusion remains connected to an official document, an exact excerpt, its location, and a human review.

The current proof of concept verifies this claim:

Programming is included in Grade 10 Computer Science education.

The claim is supported by two precise learning outcomes from the official Punjab Grade 10 Computer Science textbook:

Introduction to Python programming

“Understand basic programming concepts and set up a Python development environment.”

Location: Unit 3, Introduction to Python Programming, Student Learning Outcomes, printed page 40.

Python control structures

“Implement control structures such as decision-making statements and loops in Python.”

Location: Unit 4, Control Structures in Python, Student Learning Outcomes, printed page 55.

Both records reference the official textbook published by the Punjab Education Curriculum Training and Assessment Authority (PECTAA) and were reviewed by me, Rajab Baig.

The application currently provides:

Structured curriculum claims
Official source records
Uploaded source documents
Exact evidence excerpts and locations
Human reviewer analysis
Verification status tracking
Evidence confidence levels
Search across claims and evidence
Subject, grade, and verification-status filters
Summary statistics
Individual claim-detail pages
Responsive navigation and layout
Accessibility features
Direct links to official websites and source documents

Demo

Live application:
https://curriculum-truth-ledger.vercel.app

Deployed Sanity Studio:
https://curriculum-truth-ledger.sanity.studio
YOUTUBE VIDEO

The public application does not require a login.

Code

The complete source code is available in the public GitHub repository:

https://github.com/rajab-rajab/curriculum-truth-ledger

The frontend uses:

Next.js
React
TypeScript
Tailwind CSS
Sanity
GROQ
Vercel
My Build Process

I built the project through an iterative prompt-driven workflow using ChatGPT/Codex as my development collaborator, with VS Code and Windows PowerShell as my local environment.

I began with a simple idea: verify curriculum claims using official documents. The first version could display a claim and source, but the evidence was too weak because it contained only chapter headings.

I corrected this by returning to the textbook and replacing the broad evidence with two exact Student Learning Outcomes. This changed the project from a basic content display into a more defensible verification system.

One of the most useful prompts was essentially:

Model curriculum claims, official sources, and evidence as separate Sanity document types. Each evidence record must reference both a claim and an official source and must store an exact excerpt, location, confidence level, position, reviewer analysis, and reviewer name.

This led to three Sanity document types:

curriculumClaim
source
evidence

The Evidence Record connects a Curriculum Claim to an Official Source. This relationship is the core of the application.

The content pipeline became:

Sanity Studio
↓
Structured curriculum content
↓
Production dataset
↓
GROQ query
↓
Next.js frontend
↓
Claim, evidence, and official document

After the core content model worked, I prompted the frontend into several stages:

Retrieve published claims from Sanity.
Resolve evidence and source references through GROQ.
Display excerpts, locations, confidence levels, and reviewer analysis.
Add search.
Add subject, grade, and verification-status filters.
Add summary statistics.
Add slug-based individual claim pages.
Add shared navigation and footer components.
Improve accessibility and metadata.
Deploy the Studio and frontend.
Create a public GitHub repository with documentation and screenshots.
Where the process got stuck

The build was not a straight line.

The first evidence record was technically valid but not strong enough. It contained only unit headings. I corrected it by identifying exact learning outcomes and their printed page numbers.

The dynamic claim page initially appeared to remain on the homepage. The route folder had to be created correctly as:

app/claims/[slug]/page.tsx

I then confirmed that the published Sanity slug matched the URL used by the frontend.

During deployment, Vercel initially detected the project as “Other” instead of Next.js. The deployment completed, but the production URL returned a 404. I corrected this by adding a vercel.json framework configuration and redeploying.

I also encountered:

A duplicate local Next.js development server
A harmless browser-extension hydration warning
Windows LF/CRLF Git warnings
GitHub CLI authentication and repository setup
Vercel–GitHub connection permissions
A parent Git repository that could have accidentally included unrelated projects

To avoid publishing unrelated or sensitive files, I initialized the frontend as an independent repository and verified that .env.local, .vercel, .next, and node_modules were ignored before the first commit.

Verification

Before deployment, I ran:

npm run lint
npm run build

Both completed successfully.

The resulting application supports:

/
└── /claims/[slug]

The homepage and claim-detail route are server-rendered dynamically from the Sanity production dataset.

Sanity Project Details

Sanity project ID: dxnjdo5l

Dataset: production

Studio:
https://curriculum-truth-ledger.sanity.studio

The content model contains three document types:

Curriculum Claim

Stores:

Claim title
Claim statement
Subject
Grade level
Jurisdiction
Verification status
Verification explanation
Slug
Last verification date
Official Source

Stores:

Source title
Publisher or authority
Jurisdiction
Official website
Uploaded source document
Evidence Record

Stores:

Evidence title
Exact excerpt
Location in the source
Position
Confidence level
Reviewer analysis
Reviewer name
Review date
Reference to the claim
Reference to the official source

This structure allows the frontend to preserve the complete relationship between an assertion, its evidence, and its authoritative source.

What I Learned

The most important lesson was that structured content is not only useful for presentation. It can also preserve reasoning.

A claim, a source, and an evidence excerpt may look like ordinary content fields, but their relationships create an auditable verification trail.

I also learned that content quality matters as much as schema quality. A perfectly structured weak excerpt is still weak evidence. The application became more credible only after I replaced broad chapter headings with exact learning outcomes and page locations.

What Comes Next

This proof of concept currently focuses on one Grade 10 Computer Science claim. The same model can expand to:

More subjects and grade levels
Multiple jurisdictions and curriculum boards
Conflicting evidence
Claim revision history
Reviewer profiles
Structured citation export
Public contribution workflows
Moderation and approval states
Verification analytics

My longer-term goal is to make curriculum information easier to inspect, verify, and discuss—one claim and one source at a time.