DEV Community: Createitv

Codex Can Now Use agc-cli for HarmonyOS App Workflows

Createitv — Tue, 13 Oct 2026 06:30:48 +0000

AI coding assistants can write code, update tests, and prepare release notes. But once a workflow reaches AppGallery Connect, developers still spend time finding documentation, selecting endpoints, and assembling parameters by hand.

I wanted Codex and other coding agents to understand more than the existence of a command-line tool. They should know what to inspect first, how to choose the right workflow, how to preview a request, and when to stop for explicit user authorization.

That is why agc-cli now has two additional distribution layers:

an NPM package for installing the CLI on Windows, macOS, and Linux;
six task-oriented Agent Skills for Codex, Claude, and other compatible agents.

The website also publishes structured Schema, llms.txt, complete agent guides, and machine-readable API contracts so AI systems can read the project's capabilities without guessing from marketing copy.

Source: github.com/Createitv/agc-cli
Website: agccli.app
NPM: npmjs.com/package/@createitv/agc-cli

One NPM command across three operating systems

With Node.js 18 or later installed, the same command now works on Windows, macOS, and Linux:

npm install --global @createitv/agc-cli
agc version

The NPM package does not rely on a lifecycle script that downloads an unknown binary during installation. It contains checksum-verified release binaries for Windows x64, macOS x64/arm64, and Linux x64/arm64, with no postinstall download.

Developer workstations and unattended CI/CD machines can therefore use the same installation entry point. Homebrew, Scoop, and GitHub Releases remain available as alternatives.

Agents need workflows, not only a command list

Giving an AI model the output of --help still leaves it to guess operational boundaries. That is risky for app submissions, tester management, and release workflows.

agc-cli now provides six task-oriented Skills:

Skill	Responsibility
`agc-cli-usage`	command discovery, dry runs, authorized execution, and verification
`agc-auth`	credential profiles, identity checks, and access diagnosis
`agc-publishing`	metadata, packages, review submission, and release state
`agc-testing`	test versions, groups, testers, and feedback
`agc-reports`	distribution, install, revenue, and retention reports
`agc-cicd`	cross-platform installation, protected credentials, and CI gates

Install all six directly from GitHub:

npx --yes skills add Createitv/agc-cli --global --agent codex

Or install only the publishing workflow:

npx --yes skills add Createitv/agc-cli \
  --skill agc-publishing \
  --global \
  --agent codex

You can then ask Codex:

Use agc-cli to inspect this HarmonyOS project's release readiness. Discover the endpoints and run dry previews first. Do not submit the app. List missing parameters and the next commands.

The Skill gives the agent a safer path: discover capabilities, read endpoint documentation, check credentials and targets, then preview the request. Real invocation remains an explicit decision.

Schema explains what the project is; agent docs explain how to use it

The website now provides content for both people and AI systems:

JSON-LD SoftwareApplication Schema for the project name, author, license, operating systems, install location, and core capabilities;
llms.txt as a lightweight AI navigation file;
llms-full.txt as a complete single-file project context;
Chinese and English agent guides for task selection, safety boundaries, and verification;
skills.md for the six Skills and their installation commands;
api-reference.json for machine-readable methods, paths, parameters, and reference URLs.

These files do not guarantee search ranking, and they do not give an agent access to a Huawei account. They solve a more practical problem: Codex, Claude, and other models can retrieve consistent, explicit, and citable facts about agc-cli.

Give agc-cli to Codex in five minutes

First, install the CLI:

npm install --global @createitv/agc-cli
agc version

Second, install the Skills:

npx --yes skills add Createitv/agc-cli --global --agent codex

Third, open Codex in your HarmonyOS project and describe the goal in natural language:

Use agc-cli to list the available publishing endpoints and identify the credentials this project needs. Perform read-only checks and dry runs first. Do not upload a package or submit a release.

Service Account credentials still remain on the local machine. Never commit private keys, OAuth secrets, or ~/.agc/credentials.json, and never paste them into a public conversation.

An agent can run commands; authorization still belongs to the developer

Making a CLI understandable to an agent does not mean giving the agent unrestricted control of an app.

agc-cli endpoint commands are dry-run first. Uploading packages, changing metadata, submitting reviews, and releasing versions still require a clear target, the correct account permissions, and remote-state verification afterward.

The Skills and agent documentation preserve those boundaries:

discover before invoking;
preview before changing;
keep credentials local;
let the user explicitly decide submissions and releases;
verify remote state because a successful command is not the same as a successful review.

If you use Codex, Claude, or another coding agent for HarmonyOS development, you can now bring part of the AppGallery Connect workflow into the same development loop.

Source: github.com/Createitv/agc-cli

Installation and agent documentation: agccli.app

Issues and feature requests: GitHub Issues

Bringing Huawei App Management to the Terminal: Introducing agc-cli

Createitv — Wed, 07 Oct 2026 00:59:48 +0000

After using an App Store Connect CLI, I wanted the same command-line experience for managing Huawei apps.

asc-cli brings App Store Connect operations into the terminal. Developers can organize commands into scripts and give AI coding assistants a clear interface to work with. What appealed to me was how naturally app management became part of the development workflow.

When I applied that approach to HarmonyOS development, I still had to find individual AppGallery Connect endpoints, handle authentication, assemble parameters, and construct requests. Source code lives in version control and builds run through scripts. App management deserves an equally clear interface.

That led me to build agc-cli, an open-source Go CLI for Huawei AppGallery Connect.

Its goal is practical: reduce repeated setup and turn common app management operations into commands you can save, reuse, and compose.

Source: github.com/Createitv/agc-cli
Website and endpoint reference: agccli.app

Development efficiency extends beyond writing code

Maintaining a HarmonyOS app does not end with a successful build.

There is app information to inspect, localized metadata to check, testers to manage, reviews to handle, and reports to request. Multiple projects add another layer: confirming which account and app each operation should use.

These tasks are manageable individually, but they recur with every release. For a solo developer, they interrupt coding. For a team, they often become procedures passed along through informal instructions.

A CLI gives those procedures a concrete form. Commands describe the operation, parameters identify the target, and output supplies data for the next step. Once organized into project scripts, common tasks become easier to repeat.

One entry point for AppGallery Connect APIs

The installed command is agc. Operations are grouped by capability:

Area	Command
App metadata, localizations, and publishing requests	`agc publishing`
Test versions, testers, and groups	`agc testing`
Products, subscriptions, pricing, and promotions	`agc pms`
HarmonyOS certificates, profiles, devices, and fingerprints	`agc provisioning`
Reviews, ratings, and reports	`agc comments` / `agc reports`
Projects, SDK configuration, and domains	`agc projects` / `agc domains`

The registry contains 13 API families and 156 entries, with endpoint discovery, generic request construction, and invocation. Entries link to their official references.

Those numbers describe registry coverage, not production verification of every endpoint. Fields, permissions, and business prerequisites still follow Huawei's documentation.

Install and run your first query

On macOS, install with Homebrew:

brew tap createitv/tap
brew install agc-cli
agc version

Windows users can use Scoop; Linux users can download release archives. Release binaries do not require Go. See the English guide for platform instructions.

Prepare your AppGallery Connect app ID and Service Account JSON, then save credentials:

agc auth login \
  --service-account-file ~/.agc/service-account.json \
  --name production

Bind the default credential profile from your app's project directory:

agc init --app-id YOUR_APP_ID --default-profile production

This writes .agc/project.json. Subsequent commands select that project's profile; endpoint requests currently still require explicit app IDs and other parameters.

Preview an app information query:

agc publishing app-info-query \
  --invoke \
  --query appId=YOUR_APP_ID \
  --query lang=en-US \
  --pretty

Dry-run is the default. It constructs the request and shows the HTTP method and target URL without sending it. Add --dry-run=false to execute the query after inspection.

If the endpoint requires a client_id header, add --header client_id=YOUR_CLIENT_ID.

Example: make localized app queries reusable

Conceptual workflow: configure credentials and commands, then reuse query results in scripts.

Suppose you maintain a HarmonyOS app with Chinese and English metadata and regularly need to retrieve both versions of its app information.

Put the operation in a script. Replace the app ID and supply a client_id header if required:

mkdir -p agc-results

for lang in zh-CN en-US; do
  agc publishing app-info-query \
    --invoke \
    --query appId=YOUR_APP_ID \
    --query lang="$lang" \
    --dry-run=false \
    --out "agc-results/app-info.$lang.json"
done

--out saves the raw response body. Inspect the responses, extract the fields you need, or use them as input for your own metadata comparison scripts.

The benefit is straightforward: configure a common query once, reuse it with parameters, and keep processing the results programmatically instead of repeatedly copying information by hand.

For multiple accounts, select a profile explicitly:

agc --profile staging publishing endpoints --output table

A clear interface for scripts and AI agents

Conceptual interfaces: shared endpoint definitions support discovery, configuration, request preview, and invocation.

JSON is the default output, with table and markdown formats available for people. Scripts can pass results to jq or another program.

AI agents can inspect endpoint definitions, follow official references, and use next-command templates from affordances:

agc capabilities --output table
agc publishing endpoints --output table
agc publishing app-info-query --pretty

Discovery works without login. Agents can inspect an endpoint, fill in parameters, and construct a request. Templates provide navigation; they do not replace business-state checks or review decisions.

For further integration, agc web-server exposes a local REST API, while agc openapi exports its contract. Terminal commands, scripts, and local tools share the same endpoint registry.

Open source, built to evolve

agc-cli is MIT-licensed, with Chinese and English documentation, tests, and CI checks. Its current focus is a consistent interface to app management APIs. Complete binary/multipart upload orchestration and local Hvigor execution are not yet implemented.

If you maintain HarmonyOS apps and want common queries and management operations in your project scripts, start with your first app information query.

Source: github.com/Createitv/agc-cli

Installation and documentation: agccli.app

Report issues and suggest improvements through GitHub Issues.

A CTO Called It "God Mode" — Garry Tan Just Open-Sourced How He Ships 10,000 Lines of Code Per Week as a CEO

Createitv — Wed, 18 Mar 2026 04:12:15 +0000

Y Combinator's CEO just dropped his entire Claude Code setup on GitHub. 20,000 stars in days. One install command. Thirteen AI roles. And the internet is losing its mind.

The Tweet That Broke Dev Twitter

On March 12, 2026, Garry Tan — the man running the most powerful startup accelerator on the planet — posted a tweet that would rack up millions of impressions:

"I just open-sourced my entire Claude Code setup I used to average 10K LOC and 100 PRs per week in the last 50 days."

Within 48 hours, the GitHub repo had crossed 10,000 stars. By the time you're reading this, it's past 20,000. A CTO who tried it DM'd Tan directly: "Your gstack is crazy. This is like god mode."

That CTO predicted 90% of new repos would adopt it. Bold? Maybe. But when the CEO of YC drops his exact engineering workflow as a free, MIT-licensed toolkit, people pay attention.

Garry Tan — Y Combinator CEO, builder, and now apparently a 10,000-LOC-per-week machine. (Photo: Y Combinator)

So What Exactly Is gstack?

Here's the core insight: most people use Claude Code like a really smart intern — they tell it what to do, one thing at a time.

Garry Tan uses it like a full engineering team.

gstack is a collection of 13 specialized "skills" (slash commands) that turn Claude Code into distinct engineering roles. Each command triggers a different persona with different expertise, different priorities, and different failure modes to watch for.

Think of it this way: at a well-run startup, the CEO doesn't do code review. The QA engineer doesn't make product decisions. The release manager doesn't debate architecture. gstack encodes this separation of concerns into AI behavior.

One install command. Pure Markdown files. No dependencies beyond Claude Code itself (and Bun for the browser features). Nothing touches your PATH. Nothing runs in the background.

git clone https://github.com/garrytan/gstack.git ~/.claude/skills/gstack \
  && cd ~/.claude/skills/gstack && ./setup

That's it. You now have access to 13 engineering roles.

The 13 Roles: Your AI Engineering Team

Here's what you get:

Command	Role	What It Actually Does
`/plan-ceo-review`	CEO / Founder	Challenges your assumptions. Asks "what's the 10-star version of this?" before you write a single line
`/plan-eng-review`	Engineering Manager	Locks architecture, data flows, edge cases. Generates diagrams.
`/plan-design-review`	Senior Designer	Runs an 80-item design audit. Catches "AI slop" — those generic, soulless UI patterns
`/design-consultation`	Design Partner	Builds design systems from scratch
`/review`	Staff Engineer	Finds production bugs. Auto-fixes obvious issues. Found an XSS vulnerability that an entire human team missed
`/ship`	Release Engineer	Syncs main, runs tests, opens PRs. One command to ship
`/browse`	QA Engineer	Launches a real Chromium browser. 200ms response time. Sees your app the way users do
`/qa`	QA Lead	Tests your app, finds bugs, generates regression tests, verifies fixes
`/qa-only`	QA Reporter	Reports bugs without touching code
`/qa-design-review`	Designer + Coder	Design audit → implementation → before/after screenshots
`/setup-browser-cookies`	Session Manager	Imports real browser cookies for authenticated testing
`/retro`	Eng Manager	Analyzes your commit history. Tracks what you planned vs. what you actually shipped
`/document-release`	Technical Writer	Auto-updates stale documentation

The Browser Skill: This Is the Real Magic

Everyone talks about the slash commands. But the most technically impressive part of gstack is /browse.

Most AI coding tools that "see" your app launch a fresh browser instance every time, wait 3-5 seconds for it to spin up, then grab a screenshot. It's slow, it bloats your context window, and it's painful at scale.

Tan built something different: a persistent headless Chromium daemon that communicates over localhost HTTP. Cold start is 3-5 seconds. But after that? Every subsequent call runs in ~200ms.

That's 20x faster than the default Chrome MCP approach, with zero context bloat.

This is what unlocked /qa — Tan's self-described "massive unlock." Before the browser skill, AI code review was blind. After it? "Claude Code saying 'I SEE THE ISSUE' and then actually fixing it, generating a regression test, and verifying the fix — that changed how I work. The agent has eyes now."

Claude Code — the terminal-native AI coding agent that gstack builds on top of. (Image: Anthropic)

The Workflow: One Feature Request, Full Pipeline

Here's what happens when you use gstack on a single feature request:

/plan-ceo-review — Rethinks the product angle. "You asked for a settings page. What if it's actually an onboarding flow?"
/plan-design-review — 80-item design audit catches AI-generated UI patterns before they ship
/plan-eng-review — Architecture locked. Data flows mapped. Edge cases documented. Diagrams generated.
Coding happens — Claude Code writes ~2,400 lines across 11 files
/review — Staff-engineer-level code review. Catches a race condition. Auto-fixes it.
/qa — Opens a real browser. Clicks through the feature. Finds a preview rendering bug. Fixes it. Generates 9 regression tests.
/ship — Syncs with main, runs full test suite, opens a clean PR

From idea to pull request. One person. One AI. Multiple specialized roles.

The Numbers That Made People Lose Their Minds

Using this exact setup, over a 50-day period:

10,000+ lines of code per week (some days hitting 20,000)
100 pull requests per week
1,237 GitHub contributions in 2026 alone
All while running Y Combinator full-time

The before-and-after is striking. Here's Garry Tan's GitHub contribution graph from 2013 — when he was a full-time engineer:

2013: 772 contributions as a full-time engineer at Initialized Capital.

And here's 2026 — as a part-time coder running YC:

2026: 1,237 contributions and counting — while serving as CEO of Y Combinator. The dark green blocks in Jan-Mar tell the story.

Let that sink in. The CEO of the world's most famous startup accelerator is out-shipping most engineering teams — as a side activity. And he's coding more now, as a CEO, than he did as a full-time engineer 13 years ago.

The Controversy: "It's Just a Bunch of Prompts"

Not everyone was impressed.

YouTuber Mo Bitar released a video titled "AI is making CEOs delusional," calling gstack "essentially a bunch of prompts in a text file."

On Product Hunt, one commenter wrote: "Garry, let's be clear and honest: if you weren't the CEO of YC, this wouldn't be on PH."

The critics aren't entirely wrong. gstack is Markdown files. There's no proprietary technology. Any experienced Claude Code user has probably built some version of this workflow.

But that's exactly the point.

The value of gstack isn't that it contains secret sauce. It's that it represents an opinionated, battle-tested workflow from someone who has actually shipped thousands of PRs with it. Instead of every developer spending weeks assembling their own prompts from tweets and blog posts, you get a working baseline in one command.

It's the difference between "everyone can build a web framework" and Rails. The opinion is the product.

Why This Actually Matters

Here's the bigger picture that most people are missing:

As AI coding tools mature, the models are converging. Claude, GPT, Gemini — they'll all write decent code. The differentiation is shifting from the models themselves to the workflows built on top of them.

Claude Code's skill system. Cursor's rules. Copilot's instructions. These are all mechanisms for encoding human expertise into AI behavior. And gstack is the first viral example of an opinionated skill pack — a pre-built engineering philosophy you install in one command.

The question isn't whether gstack's specific prompts are good. It's whether "skill packs" become the standard way developers configure AI tools. Instead of every team reinventing their own prompts from scratch, you'd install a "stack" that reflects a particular engineering philosophy — like choosing Rails vs. Django vs. Express.

We might be watching the birth of a new ecosystem.

The gstack repo on GitHub — one of the fastest-growing developer tools of 2026. (Image: GitHub)

How to Get Started (5 Minutes)

Requirements: Claude Code installed, Git, Bun v1.0+ (for browser features only)

Step 1: Install gstack

git clone https://github.com/garrytan/gstack.git ~/.claude/skills/gstack \
  && cd ~/.claude/skills/gstack && ./setup

Step 2: Add to your CLAUDE.md

The setup script will guide you through adding the gstack configuration to your project's CLAUDE.md file.

Step 3: Start using commands

Start with /plan-ceo-review on your next feature
Try /review on your latest changes
Use /qa to let AI actually see and test your app
Ship with /ship when you're ready

Pro tip: You don't have to use all 13 commands. Pick the 3-4 that match your workflow and build from there. /review, /qa, and /ship are the power trio.

The Bottom Line

Whether you love it or hate it, gstack is a signal of where software development is heading. The future isn't about whether AI can write code — it obviously can. It's about how we organize AI to write code well.

Garry Tan's answer: treat it like a team, not a tool.

20,000 GitHub stars suggest a lot of people agree.