AI Skill Report Card

Packaging Executable Builds

B+78·Nov 19, 2026·Source: Web
12 / 15
Bash
# 1. Identify target platform and build type # 2. Build the executable with all dependencies bundled # 3. Place it correctly inside project structure # 4. Test it runs standalone from terminal # 5. Verify metadata (name, icon, version) is correct # Example: Linux -> Windows EXE pyinstaller --onefile --windowed --icon=app.ico --name="AppName" main.py ./dist/AppName # or test via Wine if cross-compiling
Recommendation▾
Add a concrete failure-case example (e.g., missing DLL error output and how it was diagnosed/fixed) to show troubleshooting, not just success paths.
14 / 15

Progress:

  • Step 1: Determine target output type (EXE, APK, MSI, or Web)
  • Step 2: Verify all dependencies/requirements are present in the dev environment (Linux)
  • Step 3: Build the executable using the appropriate toolchain
  • Step 4: Set metadata correctly — app name, package identifier, icon, version
  • Step 5: Place the build artifact in the correct project folder structure
  • Step 6: Bundle companion files as needed (MSI installer alongside EXE, APK alongside signing files)
  • Step 7: For web projects, wire up the download button to point to the correct packaged artifact path
  • Step 8: Run the executable via terminal to confirm it launches, is interactive, and functions correctly
  • Step 9: Fix any missing dependency, broken icon, wrong name, or crash before handoff
  • Step 10: Final confirmation — mark build as verified working

Platform-specific placement rules

EXE (Windows):

  • Output goes in dist/ or build/ folder within project
  • If an MSI installer is also required, place MSI alongside the EXE
  • Confirm icon (.ico) and app name are embedded correctly, not default/placeholder

APK (Android):

  • Place the .apk file in the project's release/output folder (e.g., android/app/build/outputs/apk/release/)
  • Keep APK alongside its signing config / keystore reference if present
  • Verify app name, package ID (applicationId), and launcher icon are correctly set in manifest/build config

Web:

  • Package project so the download button serves the correct built artifact
  • Confirm the download path matches where the final file (EXE/APK/zip) is actually stored
  • Let the requester choose the final download destination path — don't hardcode it
Recommendation▾
Include actual commands for MSI generation (e.g., WiX/NSIS) and APK signing, since these are mentioned as requirements but not demonstrated.
15 / 20

Example 1: Input: Python desktop app needs to become a Windows EXE, built from Linux. Output: Cross-compiled EXE via PyInstaller/Wine, named correctly, custom icon applied, placed in dist/AppName.exe, tested by running wine dist/AppName.exe from terminal — confirms window opens, buttons respond, no missing DLL errors.

Example 2: Input: React Native project needs an APK for testing. Output: ./gradlew assembleRelease run inside the dev environment, APK found in app/build/outputs/apk/release/app-release.apk, renamed/labeled per app name, installed on an emulator or device via adb install, confirmed app icon and name show correctly on home screen, app opens and functions.

Example 3: Input: Web project needs a "Download App" button wired to the latest build. Output: Build artifact placed in public/downloads/AppName-v1.2.apk (or .exe), download button href updated to that path, confirmed clicking button in browser downloads a working file, final storage path left open for the requester to choose.

Recommendation▾
Quick Start could show a second concrete command set (e.g., APK build) rather than only the EXE example, to better reflect the multi-platform scope of the skill.
  • Always do a real terminal run of the output file — never assume a successful build command means a working executable.
  • Check app name, icon, and identifiers explicitly; these are the most commonly forgotten details.
  • Keep installer companions (MSI) and signing artifacts (keystore for APK) bundled with the main executable, not scattered.
  • Match project folder structure conventions already in place — don't invent a new structure.
  • When something is missing (a library, an asset, a config value), add it directly rather than flagging it as a blocker — the goal is a fully working final output.
  • For web delivery, don't assume the final storage location — leave the destination path decision to the requester.
  • Shipping an executable that was only "build-tested" (compiled without errors) but never actually launched and clicked through.
  • Leaving default/placeholder icons or generic app names in the final build.
  • Forgetting to include the MSI installer when the target is a full Windows install experience, not just a standalone EXE.
  • Misplacing the APK/EXE outside the expected project folder structure, breaking the download button or deployment script.
  • Cross-compiling from Linux without verifying Windows/Android-specific dependencies are actually resolvable in that environment.
  • Hardcoding a download destination path instead of letting the requester pick it.
0
Grade B+AI Skill Framework
Scorecard
Criteria Breakdown
Quick Start
12/15
Workflow
14/15
Examples
15/20
Completeness
16/20
Format
14/15
Conciseness
13/15