Skip to main content

Getting Started

Start with one prompt​

Paste this into a coding agent that can read files and run commands. One prompt starts the workflow; it is not a promise of zero setup or unattended completion.

Follow the current instructions from https://github.com/teaql/teaql-agent-kit.
Use Rust and SQLite to build a small school management application with a
Platform, School, and School Type (Primary and Secondary).
Model first, evaluate and repair the model, generate the library and runnable
workspace, then build, test, and run one bounded query and one audited save.
Use model-aware Assist for generated APIs; do not read generated library source
for API discovery. Report exact commands, versions, results, and unresolved gaps.
Before installing tools or dependencies, show me what will be installed and
which commands need network access or elevated permissions; wait for my approval.

On a fresh machine, the agent may need to install the Agent Kit Skill, the TeaQL client, a language toolchain, and project dependencies. The exact set depends on your chosen language and what is already installed. Review each proposed installation; the agent should not silently change your system. See Start from an Example for review checkpoints and evidence expectations.

The first TeaQL journey should prove one complete loop:

model
  -> evaluate
  -> generate
  -> build or test
  -> execute a generated query
  -> change the model
  -> regenerate and review

Do not begin by reading every runtime customization page. First prove that the model, generator, generated API, and runtime work together.

Choose a Path​

Start with an Example​

Use Start from Example when you want an AI coding agent to create and verify a workspace from a small business description.

This is currently the most complete cross-stack entry path because the agent can use the generated application's instructions, live Assist, and the build command that the selected generator version actually produces.

Evaluate Java​

Use the Java path when you need Spring Boot integration, the mature Java query API, and enterprise runtime customization:

  1. Generate a Java library and runnable application from a reviewed model.
  2. Build the generated project with the build wrapper or command included in that project.
  3. Request focused Assist for the generated entity and Q request API.
  4. Execute the pattern in First Query.
  5. Follow Regenerate and Review.

The public Java documentation does not yet define one universal local generation command for every generator distribution. Use the command exposed by the selected TeaQL client or Agent Kit. TeaQL Maven plugin 1.1.1 exposes a dynamic generate goal; run mvn io.teaql:teaql-maven-plugin:1.1.1:list-services, then pass the selected target through -Dservice.

Evaluate Rust​

Use the Rust path when you need generated Rust APIs, provider-based runtimes, or single-binary deployment:

Follow the complete Rust Quick Start to generate and test both targets, start SQLite, execute an intent-declared query, persist an audited mutation, and review a regeneration diff.

cargo teaql --help
cargo teaql services
cargo teaql evaluate --input model/main.xml
cargo teaql rust-lib-core --input model/main.xml --output generated/rust-lib-core
cargo teaql rust-app-console --input model/main.xml --output generated/rust-app-console

The installed client is authoritative for available arguments. The currently generated console manifest expects the library at ../rust-lib-core/lib, so keep these output directories side by side. Run cargo test from each generated crate, then request query Assist before writing application code.

For lookup details, continue with The Cargo Toolchain and Rust Overview.

What Success Looks Like​

A first run is successful only when you can show all of the following:

  • The model evaluates without unresolved errors.
  • Generation completes and produces the expected workspace or library.
  • The generated project builds or its tests run.
  • The exact entity and request methods were obtained through model-aware Assist.
  • One query declares comment and purpose before execution.
  • A small model edit produces a predictable generated API diff.
  • No generated source was used as a handwritten customization point.

If the First Run Fails​

Read Troubleshoot First Run. For evaluation or generation failures, start with the Markdown report printed by the client rather than editing generated files.