hedera-dev avatar

hackathon-helper

PRD generation and submission validation for Hedera hackathon participants, aligned to official judging criteria

version
1.0.0
GitHub stars
37

Install

/plugin install hackathon-helper@hedera-skills

Run it inside Claude Code after adding the marketplace with /plugin marketplace add hedera-dev/hedera-skills.

Contents

Discovered from source

Skills 2

Hedera Hackathon PRD Generator

Generate a comprehensive PRD for a Hedera hackathon project, structured to maximize scores across all 7 judging criteria: Innovation (10%), Feasibility (10%), Execution (20%), Integration (15%), Validation (15%), Success (20%), and Pitch (10%).

Step 1: Gather Bounty / Track Context

Before asking any other questions, ask the participant to paste the bounty or track description they are targeting. This is critical for tailoring the PRD to what judges are specifically looking for.

Prompt them with:

Before we start, please paste the full description of the bounty or track you're submitting to. This includes the track name, description, requirements, prize details, and any specific evaluation criteria. The more context you share, the better I can tailor your PRD to what the judges are looking for.

If you're targeting multiple tracks, paste all of them.

Once the participant provides the bounty/track context:

  • Identify specific requirements, themes, or technologies mentioned in the track
  • Note any track-specific evaluation criteria beyond the standard judging rubric
  • Look for preferred Hedera services, partner integrations, or use cases called out in the track
  • Use this context to inform all subsequent questions and the generated PRD

If the participant doesn't have the track description handy, proceed with the general questions below but remind them that track alignment is scored under Innovation (10%) and that pasting the track details later will help refine the PRD.

Step 2: Gather Project Information

Ask the participant the following questions interactively. Ask them in batches of 2-3 to avoid overwhelming them. Start with the essentials, then go deeper. Adapt questions based on what was already covered in the bounty/track context.

Batch 1 - The Basics:

  1. What problem are you solving? (1-2 sentences)
  2. Who experiences this problem? (target users)
  3. Which hackathon track(s) are you targeting? (if not already clear from the bounty context)

Batch 2 - The Solution:

  1. What is your proposed solution? (high level)
  2. Why does this need to be a Web3/blockchain solution? (Why can't Web2 solve this?)
  3. Does anything like this exist on Hedera or other blockchains?

Batch 3 - Hedera Integration:

  1. Which Hedera services do you plan to use? (HTS, HCS, Smart Contracts, Scheduled Transactions, etc.)
  2. Are you planning to integrate with any Hedera ecosystem platforms? (SaucerSwap, HashPack, Kabila, etc.)
  3. How will your solution drive new Hedera accounts and transactions?

Batch 4 - Team & Execution:

  1. What is your team composition? (roles and skills)
  2. What are your MVP features for the hackathon? (top 3-5)
  3. Do you have any market validation or user feedback already?

If the user provided a problem statement or idea upfront, use that to skip or pre-fill relevant questions. Still ask about Hedera integration, team, and validation details.

Step 3: Generate the PRD

Once you have sufficient information, generate a comprehensive PRD following the template in references/prd-template.md. Write it to a file called HACKATHON-PRD.md in the project root.

Key requirements for the generated PRD:

  • If bounty/track context was provided, weave track-specific requirements throughout the PRD (especially in Solution Overview, Hedera Integration, and Innovation sections)
  • Every section must be filled with specific, actionable content based on the participant's answers
  • The Hedera Integration section must detail specific services and how they're used
  • The Network Impact section must include realistic estimates for accounts, MAA, and TPS
  • Include a Lean Canvas business model based on their answers
  • Design decisions should reference Hedera-specific trade-offs (e.g., HTS native vs ERC-20)
  • The Pitch Outline should be a ready-to-use framework for their presentation
  • Include explicit non-goals to prevent scope creep during the hackathon

Step 4: Score Prediction

After generating the PRD, provide a predicted score assessment against the judging criteria. Refer to references/judging-criteria.md for the complete rubric.

## Predicted Score Assessment

| Section | Predicted Score | Rationale | How to Improve |
|---------|----------------|-----------|----------------|
| Innovation (10%) | X/5 | [why] | [actionable tip] |
| Feasibility (10%) | X/5 | [why] | [actionable tip] |
| Execution (20%) | X/5 | [why] | [actionable tip] |
| Integration (15%) | X/5 | [why] | [actionable tip] |
| Validation (15%) | X/5 | [why] | [actionable tip] |
| Success (20%) | X/5 | [why] | [actionable tip] |
| Pitch (10%) | X/5 | [why] | [actionable tip] |

Focus improvement tips on the highest-weighted criteria (Execution 20%, Success 20%) first.

Step 5: Next Steps

After generating the PRD, suggest concrete next steps:

  1. Which MVP features to build first based on judging criteria impact
  2. Quick wins for improving Integration score (additional Hedera services to consider)
  3. Validation actions the team can take during the hackathon
  4. Pitch preparation tips

Judging Criteria Quick Reference

SectionWeightWhat Judges Look For
Execution20%MVP quality, UI/UX, team strategy, GTM plan
Success20%Impact on Hedera accounts, active accounts, TPS, exposure
Integration15%Depth of Hedera network usage, ecosystem partner leverage, creative service usage
Validation15%Market feedback cycles, early adopters, traction metrics
Innovation10%Novelty in Hedera ecosystem, new capabilities, track alignment
Feasibility10%Web3 necessity, domain knowledge, business model viability
Pitch10%Problem/solution clarity, opportunity size, Hedera representation

Key insight: Execution + Success = 40% of the total score. Integration + Validation = 30%. Focus effort accordingly.

Hedera Network Services Reference

Use these services to maximize Integration scores:

ServiceUse CaseIntegration Depth
Hedera Token Service (HTS)Fungible/non-fungible tokens, custom fees, compliance controlsHigh
Hedera Consensus Service (HCS)Ordered, timestamped messages, audit trails, event logsHigh
Smart Contracts (EVM)Solidity contracts with HTS precompiles, DeFi logicHigh
Hedera File Service (HFS)On-chain file storage, immutable documentsMedium
Scheduled TransactionsDeferred execution, multi-sig workflowsMedium
Mirror NodesHistorical data queries, analytics, indexingLow (alone)
SDK (JavaScript/Java/Go/Swift)Client-side integration with any serviceDepends on usage

Ecosystem Platforms

Integrating with ecosystem partners increases Integration and Success scores:

  • SaucerSwap - DEX, liquidity pools
  • HashPack / Kabila - Wallet providers
  • Hedera NFT Studio - NFT tooling
  • Arkhia / Validation Cloud - Infrastructure, mirror nodes
  • HashScan - Block explorer

Important Notes

  • Be encouraging but honest about gaps. The goal is to help them score higher, not to give false confidence.
  • Always explain WHY something matters in terms of the judging criteria and their weightings.
  • Emphasize that Execution (20%) and Success (20%) together account for 40% of the total score.
  • Remind participants that Integration (15%) rewards creative, non-obvious use of Hedera services.
  • Reference specific Hedera services by name and explain how they could be used.

Refer to references/judging-criteria.md for complete rubric details per section. Refer to references/prd-template.md for the PRD document structure.

Hedera Hackathon Submission Validator

Review a Hedera hackathon submission's codebase and score it against the official judging criteria. Focus on what is observable from the code, README, and documentation in the repository.

Step 1: Discover the Project

Scan the codebase to understand what was built:

  1. Read the README.md (or equivalent) for project overview
  2. Identify the tech stack:
    • package.json, Cargo.toml, go.mod, requirements.txt, etc.
    • Look for Hedera SDK dependencies (@hashgraph/sdk, hedera-sdk-*, etc.)
  3. Find Hedera integration points:
    • Search for Hedera SDK imports and usage
    • Search for HTS precompile addresses (0x167)
    • Search for Hedera service calls (token create, consensus submit, etc.)
    • Search for mirror node API calls
    • Search for ecosystem integrations (wallet connect, DEX, etc.)
  4. Assess project structure and code quality
  5. Look for documentation: architecture docs, design decisions, business model, pitch materials
  6. Check for tests and CI/CD configuration

Step 2: Score Against Each Criterion

Evaluate the submission against each of the 7 judging criteria. For each, provide a score (1-5), evidence from the codebase, and specific improvement suggestions. Refer to references/judging-criteria.md for the complete rubric with guiding questions and 1/3/5 score descriptors.

Innovation (10% weight)

Review for:

  • Is this a novel solution or a clone of existing platforms?
  • Does it introduce new capabilities to the Hedera ecosystem?
  • Does the README explain what makes it unique?
  • Check if similar projects exist (based on what you can infer from the code)

Feasibility (10% weight)

Review for:

  • Is the solution technically sound?
  • Does it genuinely require Web3/blockchain? Or could this work on Web2?
  • Is there a business model documented? (Lean Canvas, monetization strategy)
  • Does the code demonstrate domain understanding?

Execution (20% weight) - HIGHEST PRIORITY

Review for:

  • Completeness: Is this a working MVP, PoC, or just scaffolding?
  • Code quality: Clean architecture, error handling, testing?
  • UI/UX: If there's a frontend, is it polished or rough?
  • Documentation: README completeness, setup instructions, architecture docs
  • Design decisions: Are key technical choices documented and justified?
  • Strategy: Is there a roadmap or post-hackathon plan?
  • GTM: Is there a go-to-market strategy documented?

Integration (15% weight) - HIGH PRIORITY

Review for:

  • Services used: Which Hedera services are actually integrated? (HTS, HCS, Smart Contracts, HFS, Scheduled Transactions)
  • Integration depth: Is it meaningful usage or superficial? (e.g., just mirror node queries = shallow)
  • Ecosystem partners: Are any ecosystem platforms integrated? (SaucerSwap, HashPack, etc.)
  • Creativity: Is any Hedera service used in a non-obvious way?
  • Multiple services: Are multiple Hedera services combined?

Rate integration depth:

  • Mirror node queries only = 1 point
  • Single service, obvious usage = 2-3 points
  • Multiple services, meaningful usage = 3-4 points
  • Multiple services + ecosystem partners + creative usage = 5 points

Validation (15% weight)

Review for:

  • Is there evidence of external user testing? (feedback docs, user survey results, analytics)
  • Are market feedback cycles documented?
  • Is there any traction data? (user counts, sign-ups, etc.)
  • Note: This is hard to assess from code alone. Flag if no evidence is found.

Success (20% weight) - HIGHEST PRIORITY

Review for:

  • Does the solution architecture drive Hedera account creation?
  • Would usage generate meaningful TPS on the network?
  • Does it expose Hedera to new audiences?
  • Is the potential network impact documented or estimable from the code?

Pitch (10% weight)

Review for:

  • README quality as a proxy for pitch quality
  • Is the problem/solution clearly explained?
  • Are metrics and market data cited?
  • Is Hedera's role clearly articulated?
  • Is there a pitch deck or demo script in the repo?

Step 3: Generate the Scorecard

Output a comprehensive report:

# Hackathon Submission Review

## Project Summary

- **Name**: [from README]
- **Description**: [1-2 sentences]
- **Tech Stack**: [languages, frameworks, Hedera SDK version]
- **Hedera Services Used**: [list]

## Scorecard

| Section     | Score    | Weight | Weighted | Key Finding        |
| ----------- | -------- | ------ | -------- | ------------------ |
| Innovation  | X/5      | 10%    | X.X      | [one-line summary] |
| Feasibility | X/5      | 10%    | X.X      | [one-line summary] |
| Execution   | X/5      | 20%    | X.X      | [one-line summary] |
| Integration | X/5      | 15%    | X.X      | [one-line summary] |
| Validation  | X/5      | 15%    | X.X      | [one-line summary] |
| Success     | X/5      | 20%    | X.X      | [one-line summary] |
| Pitch       | X/5      | 10%    | X.X      | [one-line summary] |
| **Total**   | **X/35** |        | **X.X**  |                    |

**Estimated Final Grade: X%**

## Detailed Findings

### [Section Name] - X/5

**Evidence**: [What was found in the code]
**Gaps**: [What's missing]
**Quick Wins**: [Specific, actionable improvements]

[Repeat for each section]

## Top 5 Improvements (Ranked by Score Impact)

1. [Highest impact improvement] - affects [criteria] ([weight]%)
2. ...
3. ...
4. ...
5. ...

## Hedera Integration Depth Analysis

- Services detected: [list with evidence]
- Ecosystem integrations: [list or "none detected"]
- Creative usage: [describe or "none detected"]
- Recommendation: [specific services or integrations to add]

Step 4: Prioritized Action Items

After the scorecard, provide a prioritized list of improvements ordered by impact on the final weighted score. Focus on:

  1. Execution improvements (20% weight) - code quality, testing, documentation
  2. Success improvements (20% weight) - network impact, account creation flows
  3. Integration improvements (15% weight) - add more Hedera services, ecosystem partners
  4. Validation improvements (15% weight) - add user feedback mechanisms

For each improvement, estimate the effort (quick fix, moderate, significant) and the potential score increase.

Scoring Formula Reference

Weighted Score = (Score / 5) * (Section Weighting / 100 * 35)
Final Grade = (Sum of Weighted Scores / 35) * 100

Important Notes

  • Be constructive, not discouraging. Frame gaps as opportunities.
  • Base scores on evidence found in the codebase, not assumptions.
  • If you can't assess a criterion from the code (e.g., Validation, Pitch), say so explicitly and suggest how the team can document evidence.
  • Refer to references/judging-criteria.md for the complete rubric with detailed 1/3/5 descriptors per criterion.

Sponsors

Details

Marketplace
hedera-dev/hedera-skills
Source
plugins/hackathon-helper
Author
Hedera Dev
Category
Workflow
Keywords
hedera, hackathon, prd, validation, judging-criteria

More from hedera-dev/hedera-skills

All 10