GreenCheck AI

Inspiration

We kept seeing the same pattern everywhere — product packaging, corporate sustainability pages, ad campaigns — all covered in words like "eco-friendly," "green," and "sustainable," with almost nothing backing them up. No numbers, no timeframes, no third-party verification. This is a well-documented problem called greenwashing, and regulators like the FTC and the EU are actively trying to crack down on it, but there's no easy, instant way for an everyday consumer to check a claim themselves before making a decision.

With this year's "Earth Forward" theme, we wanted to build something that didn't just talk about sustainability in the abstract, but actually held sustainability claims accountable. That's how GreenCheck AI was born — a tool that makes greenwashing visible in seconds, not hours of research.

What it does

GreenCheck AI takes any piece of text — an ad, a sustainability report excerpt, product packaging copy — and analyzes each environmental claim inside it. For every claim, it determines whether the language is specific and measurable (a number, a timeframe, a named certification or verifier) or vague and unverifiable (buzzwords with nothing to back them up).

The result is:

• An overall Greenwashing Risk Score, color-coded so it's understandable at a glance
• The original text re-rendered with flagged phrases highlighted inline
• A claim-by-claim breakdown explaining exactly why each phrase was flagged

Importantly, GreenCheck AI doesn't claim to verify whether a company is telling the truth — that would require far more infrastructure than a hackathon weekend allows. Instead, it flags the same specificity red flags that regulators like the FTC (Green Guides) and the EU (Green Claims Directive) look for: missing timeframes, undefined terms, and absent third-party verification. It's an early-warning signal that tells a user "this deserves a closer look," not a legal verdict.

How we built it

• Frontend: [React/Next.js — fill in what was actually used], styled with Tailwind for a clean, editorial look rather than a playful one, since the tool is about accountability
• Backend: A single /analyze API endpoint that sends the pasted text to OpenAI with a structured prompt, and parses the response into a strict JSON schema (overall_score, risk_level, list of claims each with text, classification, and reason)
• AI integration: OpenAI API for the core claim analysis, with a no-API-key demo fallback mode so the app still works end-to-end for anyone testing it without setup — including judges
• Design: A risk gauge, inline highlighted text, and a claim breakdown list — built so the "why" is always visible alongside the score, not hidden behind it
• Sample claims are built in so the tool can be tested instantly without needing to find or paste your own text

Challenges we ran into

• Getting consistent, structured output from the LLM. Early on, responses were inconsistent between similar inputs. We solved this by tightening the prompt into a strict rubric with explicit criteria (does the claim have a number? a timeframe? a named verifier?) instead of leaving classification open-ended.
• Avoiding overclaiming what the tool actually does. It was tempting to market this as a "fact-checker," but we made a deliberate decision to frame it accurately as a specificity/risk signal — which meant rethinking our copy, labels, and UI language so users aren't misled about what the AI can and can't verify.
• Making the demo work without dependencies. We didn't want the live demo (or a judge testing it) to break just because an API key wasn't configured, so we built a fallback mode using canned responses — this took extra time but made the tool far more resilient.
• [Add any real blockers your team hit — deployment issues, time management, a specific bug that took hours, etc.]

Accomplishments that we're proud of

• A fully working, end-to-end MVP within the hackathon timeframe — text in, structured analysis out, no broken states
• A scoring system grounded in real regulatory criteria (FTC Green Guides / EU Green Claims Directive) rather than arbitrary AI judgment
• A no-key fallback mode, so the tool is testable by anyone instantly — no setup friction for judges
• A UI that pairs every score with visible evidence (highlighted text + reasoning), instead of just handing users an opaque number
• Being honest about the tool's limitations in our own framing, instead of overselling it as something it isn't

What we learned

• How real regulators (FTC, EU) actually define and evaluate greenwashing — and how to translate that into a rubric an AI model can consistently apply
• The difference between fact verification and pattern/specificity detection — and why the second is both more feasible and still genuinely useful
• Prompt engineering for structured, parseable output (JSON schemas) rather than free-form LLM text
• [Add a team-specific learning — e.g. "none of us had built an LLM-integrated app before," or a specific new tool/framework someone picked up]

What's next for GreenCheck AI

• Comparison mode — analyze two companies or reports side by side to see which makes more substantiated claims
• URL input — paste a link instead of raw text, and let the tool scrape and analyze a live webpage
• A lightweight verification layer — using web search to check whether a specific claim (e.g. "30% emissions cut since 2020") is corroborated by outside news or reports, clearly labeled as "supporting evidence found/not found" rather than a truth verdict
• Browser extension — flag greenwashing language directly on product pages and ads as you browse, in real time
• Crowdsourced claim database — build a public, searchable history of previously analyzed company claims over time

Built With

• claude
• gemini
• nextjs