What I Built
EffortX is an AI-powered Proof-of-Effort platform that analyzes GitHub commits and pull requests, generates engineering reviews, calculates contribution quality scores, and stores verifiable proof on-chain.
Instead of measuring developers using commit counts or contribution streaks, EffortX focuses on what actually matters:
Engineering impact.
Project Links
Live Product: https://effort-x-seven.vercel.app/
GitHub Repository: https://github.com/viv2005ek/EffortX
Demo Video: https://www.youtube.com/watch?v=obsvaDMGX60
Documentation: https://docs.google.com/document/d/1euj_EaTQ9MYlRs-LcdBlGw-yLovbWCClQ0XBH_NFy54/edit
Presentation: https://drive.google.com/file/d/1MF7-03Cyu7L1MSdAE0lbDUr6RnczowOx/view
The Story
A few weeks ago, EffortX was heading toward the same fate as many hackathon projects.
It wasn't dead.
But it wasn't finished either.
The core idea existed.
The AI analyzer existed.
The smart contract existed.
The frontend existed.
But none of those pieces worked together in a way that felt like a real product.
The repository was full of partially completed features, unfinished integrations, and ideas that had never made it across the finish line.
Like many developers, I kept telling myself:
"I'll come back to it later."
The problem is that later rarely comes.
Then I saw the GitHub Finish-Up-A-Thon.
A challenge focused on finishing abandoned projects.
The irony wasn't lost on me.
A project called EffortX needed more effort.
So I reopened the repository and started building again.
Before
When I revived EffortX, the project was missing several critical pieces.
The platform had no complete authentication workflow.
GitHub integrations were incomplete.
Repository-level permissions were not fully implemented.
Contribution reviews could not automatically appear on GitHub.
The user experience was fragmented.
Documentation was minimal.
The product felt more like a proof of concept than a platform.
Although the vision existed, the execution was unfinished.
What Changed
Over the last few weeks, I focused on transforming EffortX from a collection of working components into a complete developer experience.
The project evolved through multiple iterations and feature additions.
GitHub OAuth Integration
I implemented GitHub OAuth authentication, allowing developers to securely connect their GitHub accounts.
This became the foundation for identity verification and contribution ownership.
GitHub App Authentication
I integrated GitHub App authentication to enable repository-level access.
This allows EffortX to:
- Access commits
- Analyze pull requests
- Publish automated reviews
- Interact with repositories securely
AI Contribution Analysis
The contribution analysis engine was expanded and improved.
EffortX now evaluates:
- Technical complexity
- Architecture impact
- Maintainability
- Security considerations
- Engineering depth
The goal is to measure contribution quality rather than contribution quantity.
Automated GitHub Reviews
One of the biggest additions was automatic review publishing.
After analysis, EffortX now posts AI-generated engineering reviews directly on GitHub.
This creates transparency and immediate developer feedback.
Solana Verification Layer
The blockchain layer was finalized and connected to the application workflow.
Contribution records can now be linked to wallet identities and stored as verifiable proof.
This creates a foundation for portable developer reputation.
Redis Integration
Redis was introduced to improve authentication workflows and token management.
This significantly improved platform responsiveness and reduced unnecessary API overhead.
AI Playground Expansion
Additional AI models were integrated through Dappier.
This expanded the platform beyond contribution analysis and opened new opportunities for developers to interact with AI tools.
User Experience Improvements
I improved:
- Navigation
- Dashboard workflows
- Authentication experience
- Repository connection flow
- Documentation
- Project onboarding
The platform now feels significantly more polished and complete.
How EffortX Works
- Developers authenticate through GitHub OAuth.
- A GitHub App connects repositories securely.
- Users submit a commit or pull request.
- AI analyzes the contribution.
- Engineering reviews are generated.
- Reviews are published back to GitHub.
- Effort Scores are calculated.
- Contribution proof is stored on-chain.
- Developers build reputation based on impact.
Tech Stack
Frontend
- React
- Vite
- Tailwind CSS
- Framer Motion
Backend
- Node.js
- Express.js
- Redis
AI
- Google Gemini 2.5 Flash
- Dappier Models
Blockchain
- Solana
- Anchor
- Web3.js
Integrations
- GitHub OAuth
- GitHub App
What I Learned
The biggest lesson wasn't technical.
It was realizing how many projects fail not because the idea is bad, but because they stop just before becoming useful.
Building the first 80% is exciting.
Building the last 20% is where most projects are abandoned.
Finishing EffortX taught me that shipping a product requires a completely different level of persistence than building a prototype.
I also gained hands-on experience with:
- GitHub Apps
- OAuth workflows
- AI prompt engineering
- Blockchain integration
- Multi-service architectures
- Developer tooling
What Makes EffortX Different
Most platforms track activity.
EffortX tracks impact.
Traditional metrics focus on:
- Commit counts
- Contribution streaks
- Repository activity
EffortX focuses on:
- Contribution quality
- Engineering depth
- Architectural impact
- Verifiable reputation
The goal is to create a future where developers are recognized for meaningful work rather than raw activity.
What's Next
The Finish-Up-A-Thon helped transform EffortX from an unfinished project into a functional platform.
But this is not the end.
The next phase includes:
- GitHub Check Runs
- Team Reputation Scores
- Organization Dashboards
- Recruiter Portal
- Reputation APIs
- Cross-Platform Developer Identity
My long-term vision is to make EffortX the reputation layer for software engineering.
Because the question shouldn't be:
How many commits did you make?
It should be:
What impact did your contributions create?
This narrative is much stronger than a standard project description because it directly demonstrates the completion arc that the challenge judges care about.