DEV Community: Link Jen

How to evaluate and choose AI tools for your workflow

Link Jen — Wed, 11 Nov 2026 15:22:56 +0000

Two tools can look interchangeable on a feature list and still differ on export options, rate limits, or whether you can run them yourself. The useful work is checking a product against the job you actually have.

The checklist below follows the public review criteria on AINovaTools. The category counts and scoring thresholds I cite were taken from the site on 11 November 2026.

Start with the job

Write the task in one sentence. "Review a pull request in this repository" is enough. So is "generate a 20-second product clip from a still image," or "clone a voice for an internal demo." Then name the constraints that would make a tool unusable: budget, data residency, self-hosting, a required API, the platform (browser, CLI, or desktop), how much you will trust an unattended agent.

Only after that should you browse a category. AINovaTools groups tools into 16 categories, from productivity and coding to education and data analysis. The labels help with discovery, but they aren't exclusive. On 11 November 2026, coding listed 97 tools and productivity listed 117, while the all-tools index reported 257. If you add the category counts together you will overstate the catalog, because one listing can carry more than one tag. If the task spans two categories, shortlist from both and compare the tools against the same constraints.

Can you actually use the product?

Before building a feature matrix, apply a few hard filters. The AINovaTools editorial policy rejects a candidate, regardless of score, when any of the following is true:

The website is unreachable, permanently broken, or redirects in a malicious way.
The product impersonates another, clones one without a clear difference, shows misleading pricing, or has an unidentifiable operator.
There is malware, an illegal use case, or a clear privacy or IP problem.
It is a duplicate of an existing listing with no explainable unique value.
The page is only an affiliate or ad destination, and the product cannot actually be used or verified.

I use the same list. If I can't tell who operates the tool, can't reach a working product, or can't find a pricing or terms page, I stop. A polished landing page isn't enough.

Score what you can verify

AINovaTools scores candidates on a 100-point scale across nine weighted dimensions. You don't need to copy the weights. The questions are still a useful frame:

Search demand (20): are people looking for this tool, or only for the problem it claims to solve?
Audience fit (15): does it serve the workflow you wrote down, or a different buyer?
Freshness (10): is it maintained?
Differentiation (15): can you learn limits or failure modes that the vendor page leaves out?
Documentation (10): are the site, pricing, docs, and terms verifiable?
Credibility (10): is the operator identifiable, and does the product look stable?
Commercial intent (10): do people in this category compare options and actually buy?
Partnership potential (5): if something breaks, is there support, an issue tracker, or a status page?
Maintainability (5): can you afford to keep checking price and features as they change?

On that site, 80 or above is a priority listing, 65-79 enters a candidate pool, and below 65 is not published. For my own shortlist I use a simpler bar: if documentation, operator identity, or pricing can't be verified, I skip the tool, no matter how interesting the demo is.

Verify pricing against the official source

Headline prices are a poor summary of what you'll pay. The review methodology on AINovaTools requires every published price, quota, and limit to be checked against the official pricing page or docs, and linked from the tool page. Pages carry a Last verified date. If the vendor changes pricing after that date, the vendor's site is treated as authoritative until the next refresh. Free-tier limits and overage behavior are recorded where the vendor documents them. Those details usually matter more than the plan name.

When I evaluate a tool, I open the official pricing or billing documentation, not a roundup post. I write down the free-tier cap, what happens when you exceed it, whether a credit card is required, and whether API usage is billed separately from the app, plus the date I checked. If a third-party page and the vendor disagree, I trust the vendor.

Tests you actually ran

For its priority pages (top listings, comparisons, and "best of" picks), AINovaTools goes beyond the vendor's marketing. An editor signs up and runs a realistic task, such as a coding agent on a real repository, a text-to-speech tool on real script audio, or an OCR model on real documents, and records limits such as rate caps, quality drop-offs, missing export options, and regional restrictions. Where something has not been tested first-hand, the page is supposed to say so.

I do the same thing. A screenshot of a happy path isn't a test. Run one task that looks like your actual work, and write down what failed. If you don't have time to test a tool, keep it in an "untested" column.

User ratings deserve the same caution. AINovaTools states that ratings on tool pages come from real user submissions on that site, and that it does not display aggregate scores it cannot trace or import fabricated review counts. An unsourced star rating shouldn't decide the purchase.

Plan for the tool to change

AINovaTools re-verifies high-traffic and high-change pages on roughly a 30-day cycle, and the rest on a 90-day cycle. Tools whose websites go offline are unpublished or clearly flagged. Meaningful changes to pricing or claims update the Last verified date. Factual errors can be reported with a URL, a description, and a source; the team says it acknowledges reports within five business days.

Put a reminder on the tools you actually pay for, and re-check pricing, limits, and export paths every month or quarter. If a vendor disappears or a model is retired, you want time to switch before a workflow breaks.

Don't treat placement or payment as a review

Directories and "best of" lists often mix editorial and commercial placements. AINovaTools states that payment never changes editorial judgment: a paid submission can buy a faster review, placement visibility, and analytics, but not a better score, rating, or review conclusion. Paid and affiliate links are marked as sponsored or nofollow. Listing does not require a backlink, and editors are described as having no financial stake in listed tools.

If a write-up doesn't disclose a commercial relationship, treat a strong recommendation with more skepticism. A disclosed placement can still be accurate, but it isn't independent evidence.

Checklist

Before you adopt a tool, you should be able to answer yes, or have a documented exception, to these:

I can describe the job in one sentence and name the constraints that would make a tool unusable.
I can identify the operator and reach a working product, not only a landing page.
Pricing, quotas, and overage are copied from an official source, with the date I checked.
I have either run a realistic task myself or clearly marked the tool as untested.
I know what happens if the tool is down, the model changes, or I need to export my data.
I have not treated a paid placement, an unsourced star rating, or a category rank as a substitute for the above.

How to convert decimal hours to hours and minutes

Link Jen — Wed, 11 Nov 2026 15:21:41 +0000

Payroll systems and time trackers often store a workday as a decimal. Seven hours and forty-five minutes becomes 7.75. That's convenient for arithmetic: 7.75 plus 1.25 is exactly 9.0. It's less convenient when you have to print the same value as 7:45 on a timesheet.

The conversion is short. The bugs I've run into are almost always in the same places: how you round a fractional minute, what you do with a negative adjustment, and whether a total over 24 hours should wrap like a clock or stay a duration.

The formula

Treat the decimal as a duration, not a time of day.

Multiply the decimal hours by 60 to get a total number of minutes.
Round that total to an integer, using an explicit rounding rule.
Split the integer with division and remainder: hours are the quotient, minutes are the remainder.

So 7.75 × 60 = 465 minutes, and 465 ÷ 60 is 7 hours with 45 left over. Result: 7:45.

The same steps work for a weekly total. 25.5 × 60 = 1,530 minutes, which is 25 hours and 30 minutes, not 1:30 the next morning.

If you only need to convert a single value and don't want to open a spreadsheet, Decimal to Time will do that in a browser. The snippets below are for when the conversion has to live in your own code or timesheets.

Rounding

Almost every off-by-one I've seen in this conversion comes from rounding. 1.995 hours is 1 hour plus 0.995 × 60 = 59.7 minutes. If you take the integer part of the hours first and then round the leftover minutes, 59.7 becomes 60, and you have to carry that extra hour. Forget the carry and you print 1:60, which isn't a valid time.

It's more reliable to round the total minutes first, then split:

1.995 × 60 = 119.7
Round to 120
120 ÷ 60 = 2 hours, remainder 0
Result: 2:00

You also need to pick a rounding mode and stick to it. The snippets below use half away from zero: 0.5 minutes rounds to 1, and -0.5 minutes rounds to -1. That's usually what payroll and timesheets expect.

Don't assume a language's built-in round already does that.

Python 3's round() uses banker's rounding (ties go to the even integer), so round(2.5) is 2 and round(3.5) is 4. The Python snippet uses Decimal.ROUND_HALF_UP instead, which is half away from zero.

JavaScript's Math.round rounds ties toward +Infinity, so Math.round(1.5) is 2 but Math.round(-1.5) is -1. The snippet rounds the absolute value first, then restores the sign, so ties behave the same in both directions.

Floating-point representation can also nudge a value that should be exact, especially after you sum many entries. In Python, Decimal(str(value)) keeps ordinary timesheet values in base 10. In JavaScript, rounding the total minutes is usually enough. If you need exact decimal arithmetic, use a decimal library, or store minutes as integers from the start.

Negative values

Negative decimal hours show up as adjustments: a correction of -1.25 hours, a balance of -0.5 hours, or a reversal of a previous entry. Dropping the sign, or taking a clock-style modulo of a negative number, will give you the wrong duration.

A convention that works in practice:

For one hour or more, keep minutes in the range 0 to 59 and put the sign on the hours. -7.75 becomes -7:45, not -8:15 and not 7:-45.
Between 0 and -1 hour, there are no hours to hold the sign. -0.5 hours is 0 hours and -30 minutes, which you should still format as -0:30.

If you only attach the sign to the hours component, sign * 0 is just 0, and the minus sign disappears. Both snippets below treat that case explicitly.

If a negative duration isn't valid in your system, reject it with an error. Don't silently take the absolute value.

More than 24 hours

7.75 is a duration. So is 25.5, and so is 100.25 (100 hours and 15 minutes). These values appear in weekly timesheets, project totals, and overtime reports.

Don't reduce the hours modulo 24 unless you are converting a duration into a clock time on a 24-hour face, which is a different problem. 25:30 as a duration and 01:30 as a time of day mean different things. Excel's default h:mm format wraps at 24 hours; you need [h]:mm to keep the full hour count. The code snippets do not wrap.

JavaScript

These functions convert a finite number of decimal hours to { hours, minutes } and format them as H:MM. I ran the examples with Node.js.

function decimalHoursToHm(value) {
  if (typeof value !== "number" || !Number.isFinite(value)) {
    throw new TypeError("value must be a finite number");
  }
  // Math.round is half toward +Infinity, so round the absolute
  // value and restore the sign (half away from zero).
  const sign = value < 0 ? -1 : 1;
  const totalMinutes = sign * Math.round(Math.abs(value) * 60);
  const absolute = Math.abs(totalMinutes);
  const hours = Math.floor(absolute / 60);
  const minutes = absolute % 60;
  if (sign < 0) {
    if (hours === 0) {
      return { hours: 0, minutes: -minutes };
    }
    return { hours: -hours, minutes };
  }
  return { hours, minutes };
}

function formatHm({ hours, minutes }) {
  const sign = hours < 0 || minutes < 0 ? "-" : "";
  return `${sign}${Math.abs(hours)}:${String(Math.abs(minutes)).padStart(2, "0")}`;
}

Examples:

formatHm(decimalHoursToHm(7.75));    // "7:45"
formatHm(decimalHoursToHm(1.995));   // "2:00"
formatHm(decimalHoursToHm(25.5));    // "25:30"
formatHm(decimalHoursToHm(-7.75));   // "-7:45"
formatHm(decimalHoursToHm(-0.5));    // "-0:30"

Python

The Python version does the same conversion with decimal.Decimal, so the arithmetic stays in base 10.

from decimal import Decimal, ROUND_HALF_UP


def decimal_hours_to_hm(value) -> tuple[int, int]:
    hours_decimal = Decimal(str(value))
    total_minutes = int(
        (hours_decimal * 60).to_integral_value(rounding=ROUND_HALF_UP)
    )
    sign = -1 if total_minutes < 0 else 1
    hours, minutes = divmod(abs(total_minutes), 60)
    if sign < 0:
        if hours == 0:
            return 0, -minutes
        return -hours, minutes
    return hours, minutes


def format_hm(hours: int, minutes: int) -> str:
    sign = "-" if hours < 0 or minutes < 0 else ""
    return f"{sign}{abs(hours)}:{abs(minutes):02d}"

Decimal(str(value)) is deliberate. Decimal(7.75) would first go through a binary float; Decimal("7.75") or Decimal(str(7.75)) keeps the decimal you actually wrote. The examples above produce the same strings as the JavaScript version.

Excel and Google Sheets

If the decimal hours are in cell A1, this formula rounds to the nearest minute and formats the result as a duration, including values over 24 hours and negative values:

=IF(A1<0,"-","")&TEXT(ROUND(ABS(A1)*60,0)/1440,"[h]:mm")

ABS(A1)*60 is the total minutes; ROUND(...,0) is the same nearest-minute step as in the code. Dividing by 1440 (minutes in a day) makes an Excel or Sheets time value. [h]:mm prints hours as a duration. Plain h:mm would wrap 25.5 into 1:30. The leading IF prepends a minus sign, because TEXT on a negative time is unreliable (Excel often shows #####).

If you'd rather not use TEXT, you can build the string from integer hours and minutes. This works in current Excel (LET) and in Google Sheets:

=LET(m,ROUND(A1*60,0),IF(m<0,"-","")&INT(ABS(m)/60)&":"&TEXT(MOD(ABS(m),60),"00"))

In older Excel without LET, put =ROUND(A1*60,0) in a helper cell and use the same IF / INT / MOD pattern on that cell.

Avoid =TEXT(A1/24,"h:mm") for timesheets. It skips an explicit minute-rounding step and wraps at 24 hours, so 25.5 becomes 1:30, and 1.995 can display as 1:59 or 2:00 depending on the remainder.

Checklist

Convert total minutes first, then split into hours and minutes, so a rounded 60 minutes becomes an extra hour.
State the rounding mode. Half away from zero is a reasonable default for payroll; don't assume round() or Math.round already does that.
Treat the result as a duration. Only wrap at 24 hours if you are actually formatting a clock time.
Preserve the sign, including for values between -1 and 0 hours.
In spreadsheets, use [h]:mm, not h:mm.