TaskProof Open-Source Tool: Avoid Bounty Traps with Evidence Checklists and Expected-Value Calculations

From a $500 Bounty to Labor Cost: Where's the Problem?

Developers often mistake a "$500 bounty" for "$500 in pay." But if 80 people submit and only 1 wins, there's a huge gap between the reward upon winning and the realistic expected income. This is exactly the problem the open-source tool TaskProof aims to solve.

TaskProof is a browser-first open-source experiment aimed at freelancers and anyone evaluating developer bounties. It does three things: converts messy task briefs into evidence checklists, flags clauses worth questioning, and calculates a hypothetical hourly return using assumptions you input yourself. The author states upfront: this project has no paid services, no awards won, zero verified customers, and zero verified revenue.

Do the Math First, Then Look at the Headline

The competitive bounty example built into TaskProof illustrates the problem well. Suppose: $500 prize, 7.5% platform fee, estimated build time of 8 hours, a user-set winning probability of 15%, and $0 upfront cost.

The calculation is straightforward:

• Net prize upon winning = 500 × (1 - 7.5%) = $462.50
• Probability-weighted expected net income = 462.50 × 15% = $69.38
• Hypothetical hourly rate = 69.38 ÷ 8 ≈ $8.67/hour

The key point: 15% is not an AI prediction, nor a genuine measurement of the competition—it's just a hypothetical value on a demo slider. The real probability could be far lower. The author repeatedly stresses: $69.38 is not money in hand. The underlying formula is deliberately kept simple, with no token price predictions or mysterious "AI confidence."

Probability-weighted expected net income is a foundational concept in decision theory: it means multiplying the payoff of each possible outcome by its probability and summing them. In speculative bounty scenarios, there are only two outcomes—"win" and "don't win"—with zero payoff for not winning, so the expected income simplifies to "net prize × winning probability." The value of this number is that it reduces the eye-catching headline "$500" to "how much you can expect to get back per attempt on average."

It's important to note that expected value is not the same as the actual amount received—it only applies to the long-run average of repeated decisions. For an individual entering a bounty just once, a 15% probability means an 85% chance of getting nothing. Additionally, a platform fee typically refers to the commission a bounty platform takes from the prize; 7.5% is a common rate, but rules vary by platform, and some also involve payment gateway or withdrawal fees, which can make the actual net prize even lower.

Part One: Show Me the Evidence First

TaskProof scans the text in the brief, not your private repo or wallet. It can flag whether a post requires a public demo, a GitHub repo, tests, a README, original images, video, a blog post, or a transaction browser receipt.

It also highlights phrasing related to prepayment, requests for wallet recovery materials, external social accounts, subjective judging, and tight deadlines. These are just phrase-based reminders, not fraud accusations. The author mentions a real edge case found in regression testing: the warning "never send your private key" should not itself be treated as an instruction to send a private key.

The generated checklist includes questions like: What is the acceptance test? Who releases the funds? Is the prize split among multiple winners? Does the deadline use the local timezone? You can save your work as a Markdown evidence plan without creating an account.

Part Two: Use Open-Weight AI, Not a Hosted Prompt Box

The optional AI component uses the FLAN-T5 Small model, running inside a browser Web Worker via Transformers.js and ONNX Runtime Web. Its role is deliberately narrow: summarize a possible deliverable, suggest a question for the buyer, and draft an opener.

The model is not allowed to decide whether a prize exists. It may misread the brief, so its suggestions are explicitly marked as requiring human verification. The first run downloads public model weights and does not promise offline availability before caching. If the AI component fails, the deterministic rules and the economics calculator still work independently.

Privacy is worth noting: pasted task briefs are not sent to a hosted inference API. Model weights are downloaded to the browser, and inputs stay local. No wallet connection, API key, backend upload, or registration required.

FLAN-T5 Small is an instruction-tuned language model released by Google in 2022, part of the T5 (Text-to-Text Transfer Transformer) family. Its core idea is to unify all NLP tasks into a "text-to-text" format: input a piece of text with an instruction, and the model generates the answer directly. The FLAN version was fine-tuned on a large multi-task instruction dataset, giving it decent zero-shot instruction-following ability for prompts like "summarize this text" or "ask a question." The Small version has about 80 million parameters, with weight files of only a few hundred MB, making it suitable for loading in a browser environment.

Transformers.js is a JavaScript library from Hugging Face that lets developers call pretrained models directly in the browser or Node.js, with inference executed underneath via ONNX Runtime Web. ONNX is a cross-framework model exchange format, and ONNX Runtime Web uses WebAssembly or WebGL to accelerate computation on the client. Together, these three enable a privacy-friendly approach where "model weights are downloaded locally and inputs never leave the browser"—at the cost of downloading weights on first load and inference speed being limited by the user's device performance.

What Was Actually Tested

The repo includes unit tests for risky text, arithmetic, and input validation, as well as static site regression tests. The author says that at the time of writing, there were 24 passing tests using the Node test runner, and the publicly deployed site was checked in headless Chrome: examples, exports, key risk alerts, the calculator, and the narrow mobile layout all worked correctly.

Local reproduction steps include cloning the repo, npm ci --ignore-scripts, npm test, npm run build, and then starting a local server for the docs directory with Python. The author also honestly points out: the browser inference path has additional runtime requirements and needs browser-side verification; passing Node tests does not mean the model output is correct. Third-party model weights and packages retain their respective licenses.

Side-Project Assumptions and Unverified Reality

The author envisions a narrow-scope service: human-verified pre-checks of briefs, aimed at freelancers or small teams—objective acceptance checklists, withdrawal questions, and reproducible effort estimates. Possible pricing is $19 for a one-time brief or $9 per month for the tool, but this is just an experiment and currently cannot be purchased. The author says that rather than pretending a checkout page means product-market fit, he'd rather first verify whether this solves a painful process.

In addition, the author maintains a free GitHub Actions workflow risk-checking tool and offers a clearly scoped CI workflow fix service starting at $149, with a quote required after discussion first.

Finally, the author states again: no paid customer has been verified, no prize has been won, and no payment has been received for any project. The next useful signal isn't page views—it's one real person saying, "Yes, I'd use this to decide whether to take this gig."

If you've ever wasted a weekend on a speculative bounty, what one piece of information would have made you change your mind before starting?

One-line Summary

TaskProof uses evidence checklists and probability-weighted hourly rates to help freelancers see the true returns of speculative bounties.

Paragraph Summary

TaskProof is a browser-first open-source experiment designed to solve the problem of developers mistaking a "$500 bounty" for "$500 in pay." It scans task brief text, generates evidence checklists, flags risky clauses, and calculates a hypothetical hourly rate using a user-set winning probability—for example, a $500 prize, 7.5% platform fee, 15% winning probability, and 8 hours of work yield an expected return of about $8.67/hour. The optional AI component uses FLAN-T5 Small running locally in the browser, used only to summarize deliverables and draft questions, not to judge whether a prize is real. The project includes 24 passing Node tests, but the author emphasizes zero verified customers and zero verified revenue, with all economic calculations based on assumptions rather than facts.