Forem: Csaba8472

App Release Copilot: AI-Powered App Store Metadata from Your Terminal

Csaba8472 — Sun, 15 Feb 2026 21:18:00 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

APP Release Copilot — a chat-style CLI that generates AI-powered App Store Optimization (ASO) metadata for iOS apps, powered by the GitHub Copilot SDK.

As an indie iOS developer, I've always found writing App Store metadata tedious and time-consuming. Crafting the perfect title within 30 characters, squeezing meaningful keywords into 100 characters, and writing a description that hooks users in the first 3 lines — it's a skill of its own. I wanted a tool that brings AI directly into my terminal workflow, right where I already spend most of my time.

APP Release Copilot connects to GitHub Copilot through the @github/copilot-sdk, integrates with a custom MCP server for real-time keyword traffic and difficulty scoring, and outputs metadata in your terminal.

Key Features

Slash-command interface — /title, /subtitle, /desc, /keywords, /release, /promo, /full
Natural language refinement — type "make it shorter" or "focus on productivity" to iterate
Live keyword scoring — MCP-powered tool calls analyze keyword traffic & difficulty in real-time
Character limit awareness — color-coded counts (green ≤80%, yellow ≤100%, red over limit)
Dynamic model selection — pick from all available Copilot models at startup (GPT-4o, Claude Sonnet, o-series)
App Store competitor import — /url fetches any competitor's App Store listing for context
App icon & feature graphic generation — /icon and /feature produce store-ready images via OpenAI or Gemini, with 16 style presets adapted from SnapAI
Beautiful TUI — gradient ASCII logo, box-drawn panels, progress bars, model badges

Demo

GitHub Repo: github.com/Csaba8472/app-release-copilot

Typical Workflow

❯  /title                     # Generate 5 title options (30 chars each)
❯  more like option 3         # Refine with natural language
❯  /keywords                  # Generate keyword string with live MCP scoring
❯  /desc                      # Full App Store description

Each generation shows real-time spinner states — "📊 Analyzing keyword scores..." when MCP tools fire, "✨ Writing title options... (12 lines)" as content streams in.

Export Output

{
  "configVersion": 0,
  "apple": {
    "info": {
      "en-US": {
        "title": "foodie - ai cal food tracker",
        "subtitle": "Snap, Track & Eat Smarter",
        "description": "Transform your meals into insights...",
        "keywords": ["calorie,tracker,food,photo,ai,nutrition,diet,meal,snap,health"],
        "releaseNotes": "What's new in foodie 2.0...",
        "promoText": "Track calories instantly — just snap a photo!"
      }
    }
  }
}

My Experience with GitHub Copilot CLI

This project is deeply intertwined with GitHub Copilot at two levels:

1. Built ON GitHub Copilot

APP Release Copilot isn't just built with Copilot — it runs on it. The entire AI backbone uses the @github/copilot-sdk:

CopilotClient manages authentication, sessions, and model lifecycle
Streaming sessions with event-driven architecture (assistant.message_delta, tool.execution_start, session.idle)
MCP server integration — the SDK connects to my custom MCP server at aso-mcp.vercel.app for real-time keyword traffic/difficulty scoring via the get_keyword_scores tool
Quota tracking — usage snapshots from assistant.usage events update the status bar in real-time
Dynamic model listing — client.listModels() fetches available models at startup, so users always see what's currently offered

The system prompt is a carefully crafted ASO expert persona with character limits baked in, so the AI natively respects the 30-char title limit, 100-char keyword budget, etc.

2. Built WITH GitHub Copilot

During development, GitHub Copilot was my constant pair programmer:

Architecture decisions — Copilot helped design the event-driven streaming architecture, suggesting the SessionEvent switch-case pattern for handling deltas, tool executions, and quota snapshots
ASO domain expertise — the system prompt itself was co-authored with Copilot, refining App Store best practices like "use singular keyword forms (Apple matches plurals automatically)" and "don't repeat title words in keywords"
Terminal UI — the gradient ASCII logo, box-drawing helpers, and progress bar utilities were iterated on with Copilot's suggestions
Edge cases — the double Ctrl+C exit pattern, ExitPromptError handling for every @inquirer/prompts call, and graceful cleanup sequences all came together faster with Copilot's awareness of Node.js patterns

What Made the Difference

The biggest impact was on the MCP integration. Wiring up the Copilot SDK's MCP server support — where the AI autonomously decides to call get_keyword_scores during keyword generation — would have taken much longer without Copilot understanding the SDK's patterns. The streaming event model, in particular, has nuances (when to resolve the Promise, how to track tool completions) that Copilot navigated with me step by step.

The result is a tool I actually use for my own apps.

Tech Stack: TypeScript, @github/copilot-sdk, @inquirer/prompts, Commander.js, Chalk, Ora, Clipboardy

License: MIT

Binding Lottie (or any other Swift framework with UI) in MAUI

Csaba8472 — Tue, 12 Jul 2022 06:57:23 +0000

This post is part of #MAUIUIJuly. It's a great initiative to share helpful content with the community.

What is Lottie?

Lottie is a library for Android, iOS, Web, and Windows that parses Adobe After Effects animations exported as json with Bodymovin and renders them natively on mobile and on the web!
For the first time, designers can create and ship beautiful animations without an engineer painstakingly recreating it by hand.

Why bind?

When I wrote my app which needed Lottie animations, I found LottieXamarin library, but that only works with Xamarin.Forms not with MAUI. I tried to update it, however I've run into multiple issues and at the same time I've realised only older Lottie versions can be binded, because from March of 2019, Lottie is a Swift library, which means it can't be binded easily. With the binding solution I'll show below you can bind the latest version.

The other option is Skottie which was released after I'd already done my Lottie binding. I think Skottie is a viable alternative, based on your project needs can you select the best option.

Getting Started

I have two great resources for binding a library:

Swift binding walkthrough

To bind Lottie I chose slim binding approach, please check the video for the details.

This post would like to give a high level overview how view binding can be done, for the details please check the resources above and LottieMaui repo.

Let's start with Android

LottieProxy

LottieAnimationViewWrapper does what the name suggest. It wraps LottieAnimationView which means, it initializes, exposes the View and makes the caller able to set the animation. The class itself is in an android library.

In the video above there is a script which downloads all the dependencies. Here you can find it, so you can easily paste it in your gradle.

Lottie.Proxy.Binding

Nothing to see here, this is to connect the .net world with the android library. This project simplifies our job with not forcing us to bind 100% of any library, but only what we need (and already wrote in LottieProxy).

Then make it work on iOS

LottieProxyiOS

On iOS side to keep it clean, I've used Carthage to get Lottie. The wrapping is pretty much the same, the goal is to make sure we can set the animation and get the view.

I've borrowed the build script from the Swift binding walkthrough.

LottieProxyiOS.Binding

After you run sharpie you'll get an interface close to this:

The good thing is you have 100% control over what will be binded, so if you run any issue, it's much easier to fix as you would do the binding against the whole Lottie framework.

Don't forget to include all the frameworks and you see absolute paths here because relative paths don't always work for me.

Common

Lottie.Maui

Okay, we have the Lottie binding, now what? Let's use one of the greatest addition of MAUI, handlers. You'll find in this post the steps for LottieMaui, and please find here the detailed description.

First step is to define our interface:

Then implement the interface:

Then create the LottieHandler with mappers. This is a partial class, the most interesting things will be happening in the Platform folder. Basically, there will be connected the binded C# libraries with our cross-platform app. As you see below I've only implemented what I needed. I wanted to show an animation loop, so I only implemented those parts. Later, anything else can be easily added.

Don't forget to add the handler:

handlers.AddHandler(typeof(ILottieView), typeof(LottieHandler));

Lottie.Maui iOS handler

Lottie.Maui Android handler

And last but not least, you can add LottieView to your app, and you'll have the looping animation:

If you made it here, you're awesome! I hope this post is going to be helpful.

I mentioned above, I implemented all this for my app, which is a Microsoft To Do client for Apple Watch and Wear OS devices. You can download from the AppStore and from Play Store

You can find all the code here: https://github.com/Csaba8472/LottieMaui