Skip to content
Skills Library
Programming · Building & coding

portable-application-implementation

/portable-application-implementation

Portable application implementation. Use for Literate AI workflow tasks.

Repository
literate-ai ↗
Licence
Apache-2.0
Last repository change
27.10.2026

Assessment and security

87/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability21 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content26 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Portable application implementation. Use for Literate AI workflow tasks.

Original author description

Portable application implementation. Use for Literate AI workflow tasks.

How it works

SKILL.md has no level-two headings · 32 lines, 979 words

SKILL.md preview
---
name: "portable-application-implementation"
description: "Portable application implementation. Use for Literate AI workflow tasks."
metadata:
  author: "Literate AI maintainers <literate-ai-maintainers@users.noreply.github.com>"
schema: "urn:literate-ai:schema:v1:specification-to-source-skill"
skill_id: "portable-application-implementation"
version: "1.8.4"
title: "Portable application implementation"
stages:
  - "generate"
dependencies:
  - schema: "urn:literate-ai:schema:v1:skill-reference"
    skill_id: "portable-specification-planning"
    version: "1.1.0"
    identity:
      schema: "urn:literate-ai:schema:v1:content-identity"
      algorithm: "sha256"
      digest: "7bfdd0ddf52d2ddf5d6ac5ed6536b999da474323978937e72f4e4d3b1dface38"
limitations:
  - "Do not hard-code the acceptance input or its expected result."
  - "Do not download dependencies, invoke package managers, or read another source tree."
  - "Do not write plans, caches, binaries, or prose into the generated source tree."
  - "Do not scatter fungible generated application source at the host repository root or treat _build as mandatory for load-bearing project authority."
  - "Do not read, preserve, or treat a prior generated test manifest as authoritative, and do not turn generated implementation tests into acceptance evidence or a verifier oracle."
  - "Do not read the request from standard input or emit logs or presentation text alongside the single JSON result."
  - "Do not place any generated source file in a directory whose name source indexers conventionally ignore: build, dist, out, target, obj, bin, coverage, vendor, node_modules, or any dot-prefixed cache directory. Name a directory holding generated helper source for its role instead, such as source/tools/ or source/scripts/."
  - "Do not expand the framework-supplied LITAI_LANGUAGE_TOOL unquoted in a generated Make recipe; invoke it as the exact double-quoted `\"$(LITAI_LANGUAGE_TOOL)\"` executable token."
trust: "repository-reviewed"
---
# Portable application implementation

Implement the approved plan as a complete, deterministic application using only the selected Flavor requirements and explicitly allowed dependencies. Treat `acceptance/execution.json` as public interface authority: implement its entrypoint, positional argument array, nested argument shapes, and complete result shape exactly, while treating its concrete invocation values as verifier-owned values that must not appear in generated implementation tests. Keep platform-neutral behavior in portable code, compute results from runtime arguments, emit the exact specified JSON-compatible result, and keep fungible generated application source beneath the required `source/` directory of the generation workspace (see `repository-layout` for the advisory-cache-prefix rule governing `BUILD_DIR`/`_build`).
For every major rebuild, generate a fresh disposable implementation-test manifest at source/tests/manifest.json using schema urn:literate-ai:schema:v1:generated-test-suite. Bind it to the exact recipe_identity and generation_mode major-rebuild; generate 3 through 256 cases with unique case_id and arguments values; include example, boundary, and invariant categories; give every case exactly case_id, category, specification_refs, arguments, and expected_result; and cite only current non-acceptance recipe documents. Write the manifest as compact canonical JSON with lexicographically sorted object keys and no insignificant whitespace. Canonical JSON v1 forbids floating-point numbers at every depth: represent a fractional domain value as a decimal string, or as an integer with a scale defined by a cited specification, without rounding or changing its semantics.
Each specification_refs entry is one of those document paths copied byte for byte, never a path decorated with a heading anchor, section title, requirement ID, line number, or #fragment, and never a requirement name standing in for its document path. Derive expected results from those cited specifications and use argument vectors distinct from every acceptance/execution.json invocation. Every manifest case must have a corresponding language-native behavior test which invokes the application logic with the same arguments and asserts the same complete expected result. Make every such native test reachable from the generated build system's ordinary test target, including bazel test //... when Bazel is selected. Recalculate every manifest expectation independently before encoding it in both places.
Never read, embed, include, or parse the manifest from application or test code at compile time or runtime; it is lifecycle metadata, while the matching native tests are executable evidence.

The runnable artifact SHALL take exactly one command-line argument: a complete UTF-8 JSON array of the application's arguments, and SHALL spread that array's elements as the application's positional arguments. A specification describing "one JSON object as its first argument" therefore receives `[{...}]` on the command line and passes the single object through, rather than receiving the bare object. This is the same contract the independent acceptance verifier uses to invoke the built artifact, so an implementation that accepts the bare object will pass its own generated tests and still fail acceptance. In a composite application, this wrapper belongs only at the externally invoked artifact boundary. An internal role invoked by the trusted host runner SHALL parse exactly the role-specific value that the Component contract says the runner passes;
for example, a frontend receiving a canonical backend object as its sole application argument parses that bare object and MUST NOT require or unwrap an additional JSON array. Give the runnable artifact two framework-owned, non-product modes before normal JSON argument parsing. `--litai-test` SHALL run every current generated native behavior case and emit exactly `{"schema":"literate-ai/generated-test-results@1","cases":[...]}` with one unique `{"case_id":"...","outcome":"passed"}` entry for every and only manifest case; a failed case SHALL exit nonzero and never be reported as passed. `--litai-smoke` SHALL execute one current non-acceptance generated example through the real application logic and emit its ordinary JSON result. Runtime-dependency capabilities (the `LITAI_CAPABILITY_*` bindings for `dependency_kind: runtime` edges) are not guaranteed to be bound during `--litai-test`;
the Standard lifecycle binds them when it executes `--litai-smoke` with the real providers running. Generated tests SHALL therefore be hermetic: exercise the consumer's logic against an in-test stub of the provider's public process contract, and never require, locate, or launch the real provider or read its capability variable. Keep the mode dispatcher thin, delegate to generated test code rather than reading the manifest, and do not expose either mode as product behavior. These modes let the Standard lifecycle test and execute the built artifact after source custody is gone without turning verifier data into generated authority.

When Bazel and Rust are selected, every generated `rust_binary`, `rust_library`, and `rust_test` rule SHALL declare `srcs` as an inline string-list literal. Do not assign the source list to a Starlark variable, use `glob()`, concatenate expressions, or otherwise make `srcs` indirect. Include the crate root and every statically named `mod` or `#[path]` source reachable from it in each compiling rule's literal `srcs` list so the framework can prove the complete sandbox input closure before admitting the candidate. When that list names more than one Rust file, also set `crate_root` explicitly (for example `crate_root = "main.rs"`); the framework rejects a multi-file rule whose root Bazel cannot infer.

Every file written into `source/` is indexed as generated source before the build is
authorized. Source indexers skip directories whose names conventionally hold derived
output — `build`, `dist`, `out`, `target`, `obj`, `bin`, `coverage`, `vendor`,
`node_modules`, and dot-prefixed caches — so a generated file placed in one is declared
by the source tree but never indexed, and the lifecycle fails closed before it builds.
Name a directory for the role its contents play, not for the phase that consumes them:
put a generated bundler, packager, or cleanup helper under `source/tools/` or
`source/scripts/`, never `source/build/`. This constrains only where generated *source*
lives; the build may still write its derived artifacts to `OBJECT_ROOT`/`OUT` beneath
`_build`.

When the selected build system emits a Makefile, treat `LITAI_LANGUAGE_TOOL` as one
opaque executable path supplied by the framework. Every recipe or helper invocation of
that tool must begin with the exact double-quoted expansion
`"$(LITAI_LANGUAGE_TOOL)"`; never emit an unquoted `$(LITAI_LANGUAGE_TOOL)` command.
This common portable-application rule applies to every language descendant because a
framework-selected executable may contain spaces on Windows even when the generator's
local default is a single command word.

Versions

RepositoryScoreLicence
This page · jordanhubbard/literate-ai87Apache-2.0
jordanhubbard/literate-ai87Apache-2.0

Identical content appears in 1 other GitHub folders. We show one copy with the highest score.

Database snapshot: 13.11.2026 · package version 6a138b0d3eb2 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 87portable-application
    Portable complete application generation. Use for Literate AI workflow tasks.
  • 87go-portable-application
    Go portable JSON application. Use for Literate AI workflow tasks.
  • 86portable-app-handoff
    Use when publishing an app for reuse on other devices.
  • 85portable-text
    Work with Portable Text, a JSON-based specification for structured block content. Use this skill to render Portable Text in React, HTML, Vue, Svelte, or Markdown, to build a block content editor with @portabletext/editor, or to convert HTML and Markdown into Portable Text.
  • 100portable-text-serialization
    Render and serialize Portable Text to React, Svelte, Vue, Astro, HTML, Markdown, and plain text. Use when implementing Portable Text rendering in any frontend framework, building custom serializers for non-standard block types, converting Portable Text to HTML strings…
  • 95portable-skill-installer
    Inspect, validate, package, and install a portable Agent Skill into a user, project, or explicitly chosen directory. Use when a skill repository must be installed safely without assuming a vendor, model, account, or fixed path.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.