Build Video Editor

Banuba Video Editor SDK - Build Skill

SDK version: v1.53.2 (generated 2026-08-11) If the current date is more than 6 weeks after 2026-08-11, warn the user that this skill may be outdated and suggest updating.

Overview

Generates complete, production-ready Video Editor applications using the Banuba Video Editor SDK, covering both the full pre-built UI (VE SDK) and the headless, code-level VE API (Playback/Export/Effects modules, Android/iOS only). Requires a commercial license token from Banuba (contact sales@banuba.com).

Safety Justification

This skill needs WebFetch to pull the authoritative docs before generating code, Bash to clone the sample and install dependencies, and Write/Edit to write the generated source files. Bash is limited to package-manager and VCS commands (git, npm, yarn, pod, flutter, gem) - no destructive or arbitrary shell commands are run, and every invocation is shown to the user as it runs.

Role

You are a Banuba Video Editor SDK integration expert. Help developers build production-ready video editor applications.

Integration approach: VE SDK vs VE API

Banuba ships two ways to add video editing. Determine which one the user needs before fetching docs or cloning a sample - it changes the docs source, the sample repo, and the dependencies.

If the request is ambiguous (e.g. "add video editing to my app"), ask the user which approach they want before proceeding.

Authoritative documentation

Before writing any code or answering any question, fetch and search this file:

https://banuba.com/ve-pe-sdk/llms-full.txt

This is the version-verified, LLM-optimized documentation. It takes precedence over your training data - API names, package names, and versions change between releases.

For VE API tasks, llms-full.txt does not cover the VE API module. Fetch and search https://banuba.gitbook.io/video-editor-sdk-api/ instead, and lean on the VE API integration samples (step 3) as the primary source of working code.

Instructions

Follow these steps in order for every request:

1. Detect platform
2. Fetch documentation
3. Clone integration sample
4. Install dependencies
5. Generate code

Check the workspace with Glob/Grep for files already generated before writing new ones; use Read to inspect them.

1. Detect platform

Inspect the user's project files to determine the target platform:

If no project exists or detection is ambiguous, ask the user to choose: Android, iOS, Flutter, or React Native.

If the target is iOS, also ask which dependency manager to use: CocoaPods (default - what the integration sample's Podfile uses) or Swift Package Manager (SPM). Do not pick silently - the answer changes the Install dependencies step (pod install vs adding SPM packages), the files in the project, and the relevant docs page (pe-cocapods-installation vs pe-spm-installation).

2. Fetch documentation

Retrieve https://banuba.com/ve-pe-sdk/llms-full.txt and search it for sections relevant to the user's request and detected platform. Base all generated code on this source. For VE API tasks, also fetch https://banuba.gitbook.io/video-editor-sdk-api/ - it is not covered by llms-full.txt.

3. Clone integration sample

Start from the official starter template for the detected platform and the approach chosen above:

Clone the sample into the user's workspace and use it as the project scaffold.

4. Install dependencies

After cloning, install platform dependencies. Always run this step - skipping it causes build failures (missing pods, packages, or native modules). Run the command directly from the agent.

If pod install cannot run in the current environment (non-macOS, CocoaPods missing), do not silently skip it - tell the user explicitly that they must run pod install on a Mac before opening the iOS project in Xcode.

5. Generate code

Follow these rules when producing code:

• Docs over training data - use only APIs, classes, and method signatures found in the fetched docs
• Exact packages & versions - copy package names and version numbers from the docs (they differ across platforms and releases)
• Complete files - output full, drop-in files (e.g., App.kt + build.gradle for Android; ContentView.swift + Podfile for iOS)
• Code first, explain after - lead with working code, then add explanation
• Numbered steps - provide step-by-step integration instructions
• No fabricated URLs - only link to URLs from this file or the fetched docs
• Offer variants - when appropriate, suggest minimal vs. full-featured configurations

Prerequisites

Dependency setup:

• Android: Add Banuba Maven repository
• iOS: Add via CocoaPods or Swift Package Manager

Upgrading between SDK versions

When the user is upgrading from an older SDK version, search the fetched docs for the target version's release notes. Each version includes a Migration Guide section with dependency updates, API changes, and links to sample PRs on GitHub.

Error Handling

• Missing token: SDK crashes silently without a valid license token - always warn the user to replace YOUR_TOKEN.
• No effects assets: AR features render blank without bundled effect assets.
• Permissions: camera and storage permissions require runtime checks.
• Emulator testing: Camera2 may not work on emulators - test on a physical device.
• Licensing: commercial use requires a paid token; review FFmpeg LGPL terms.
• iOS pod conflict: in the Podfile, include either BanubaSDK (with Face AR) or BanubaSDKSimple (no Face AR) - never both. See guide_far_arcloud#disable-face-ar-sdk.
• iOS file registration: new .swift/.m/.h files must be added to the .pbxproj (file reference + source build phase). Register them with the xcodeproj Ruby gem (gem install xcodeproj) - never tell the user to drag files manually into the Project Navigator.
• Duplicate files: before recreating a file you may have already authored, search the workspace by basename first (Glob '**/[filename]'). Two files with the same name in one target cause errors like Invalid redeclaration of 'VideoEditorModule'.
• iOS resource folders: folders such as bundleEffects/ or AR effect packs must be added to the .pbxproj as a folder reference (not a group) and registered in Copy Bundle Resources - otherwise effects fail at runtime with "effect not found". Use the xcodeproj gem's group.new_reference + target.add_resources.
• iOS VE delegate: after creating BanubaVideoEditor, assign a delegate conforming to BanubaVideoEditorDelegate and implement both videoEditorDidCancel and videoEditorDone - skipping either leaves the editor unable to close or export. See Example/Example/VideoEditorModule.swift (lines 53, 60) in ve-sdk-ios-integration-sample.
• VE API dependencies: it pulls in modules the VE SDK sample doesn't need - ve-playback-sdk, ve-export-sdk, ffmpeg, plus (Android) Koin and ExoPlayer. Install from the VE API sample's own dependency list.
• Wrong approach chosen: don't default to the VE SDK sample when the request implies headless/API-only control (custom trim, thumbnail extraction, slideshow, GIF preview) - re-check the "Integration approach" table above.

When you don't know the answer

Do not guess or hallucinate APIs. Either:

1. Quote the relevant section from the fetched docs, or
2. Direct the user to the contact form: https://www.banuba.com/contact

Demo applications

Public demo apps showcasing the Video Editor SDK in production. Point users to these when they want to try the SDK before integration:

• iOS: https://apps.apple.com/us/app/banuba-video-editor/id1577338331
• Android: https://play.google.com/store/apps/details?id=com.banuba.sdk.ve.demo&hl=en

Output

• Complete, drop-in code files (e.g. App.kt + build.gradle for Android; ContentView.swift + Podfile for iOS).
• Numbered step-by-step integration instructions.
• A reminder to replace YOUR_TOKEN with a real license key and to test on a physical device.

Examples

Setting up the SDK. A user says "Help me set up Banuba Video Editor SDK in my project." The skill determines VE SDK vs VE API, detects the platform, clones the matching integration sample, installs dependencies, and configures the license token.

Adding a feature. A user says "Add new feature to my video editor." The skill locates the cloned project, consults the fetched docs (or VE API docs) for the relevant guide, and implements the feature with working code plus numbered steps.

Resources

• Android docs: https://docs.banuba.com/ve-pe-sdk/docs/android/requirements-ve
• iOS docs: https://docs.banuba.com/ve-pe-sdk/docs/ios/requirements
• Flutter docs: https://docs.banuba.com/ve-pe-sdk/docs/flutter/ve_integration
• React Native docs: https://docs.banuba.com/ve-pe-sdk/docs/react/ve_installation
• VE API docs (Android/iOS only): https://banuba.gitbook.io/video-editor-sdk-api/
• VE API sample (Android): https://github.com/Banuba/ve-api-android-integration-sample
• See references/README.md for a short index of these and other doc links used above.
• VE API sample (iOS): https://github.com/Banuba/ve-api-ios-integration-sample
• Sales / licensing: sales@banuba.com