Skip to content

Kast

Kast helps an engineer tell the difference between a plausible reading of Kotlin code and a repository answer grounded in compiler identity, semantic relationships, and explicit coverage.

The difference is visible in one line

Consider a checkout service that imports one of several declarations named PricePolicy:

import billing.PricePolicy as BillingPricePolicy

class Checkout(private val policy: BillingPricePolicy) {
    fun total(order: Order): Money = policy.price(order)
}

  • Text can suggest

    A search can find every PricePolicy token and rank nearby files. It cannot prove which declaration owns policy or which overload receives order.

  • Compiler evidence can establish

    The property has one exact compiler identity. The call binds to one exact price declaration, with a source location and typed relationship between both ends.

That distinction matters most when the answer must cover more than one file. Kast keeps the workspace, scope, source generation, coverage, and limitations attached to the evidence.

Start with the repository question

Each page below has one job. It shows where compiler-grounded evidence changes the answer and where that evidence stops.

  • What declaration does this actually refer to?

    Separate exact identity from a matching name.

    Resolve a declaration

  • What depends on this API?

    Follow references, callers, implementations, and hierarchy from one resolved declaration.

    Find semantic dependents

  • Where can this value flow?

    Use compiler-visible relationships without claiming runtime provenance.

    Bound value-flow claims

  • What must change if this contract changes?

    Turn a declaration change into a bounded semantic impact set.

    Assess a contract change

  • Did this change reach every semantic dependency?

    Distinguish no matches from a complete negative answer.

    Verify semantic coverage

Trust the boundary

A useful Kast answer says whether its evidence is complete, qualified, or rejected. When can you trust a Kast answer? explains those states. The generated CLI contract states mechanically knowable command and result facts without duplicating them in authored prose.