Here is a video introducing the latest pro@coder v0.5.2 release with the new Workbench concept.

Also, more features were released, see the release notes below.

pro@coder - v0.5.2 - Release notes

Install/Upgrade: aip install pro@coder

Rename your coder-prompt.md to coder-prompt-old.md

Major change: doubling down on workbench rather than dev, and support for spec

# Default dir: .aipack/.prompt/pro@coder/workbench-default 
workbench:
  # dir:  .aipack/.prompt/pro@coder/workbench-default
  # chat: true
  # spec: true
  # plan: true

New/Changed:

• Now full workbench: mode, replacing the old dev:

• By default, it will create .aipack/.prompt/pro@coder/workbench-default/

• But you can set any dir: _workbench/cool-feature/, and the chat.md, spec.md, and plan.md files will be created in this folder, as set to : true

• Now chat.md instead of dev-chat.md

• Now a single plan.md instead of plan-1, etc. Still has the _plan-rules.md

• Now supports spec, with spec.md and _spec-rules.md

• The sub-agent can now be on the coder end event with on: ["start", "end"]

• structure_globs: is not generated by default in the coder-prompt.md, but it is still supported

See the readme for more info: https://github.com/aipack-ai/packs-pro/blob/main/pro/coder/README.md

The readme is also available under .aipack/.prompt/pro@coder/README.md, and you can activate it in knowledge_globs:

TL;DR: Flash 3 picks better coding context than GPT-5.4 Mini on medium tasks; Mini-High narrows the gap.

In our production coding workflow, we use the LISP model:

Lens ➜ Index ➜ Select ➜ Perform

• Lens (globs) ➜ Human defines what the model can see

• Index (code-map) ➜ AI maps the lensed material, for each file: summary, when to use, public types, public functions

• Select (auto-context) ➜ AI picks the relevant files for the prompt

• Perform (main work) ➜ AI executes with precise context

The auto-context stage takes the user request plus project-level summaries and decides which files the final coding model should receive. That decision has a direct impact on output quality. If the wrong files are selected, the downstream coding step starts with the wrong context, or with too much context, even if the execution model itself is strong.

Note: AIPack v0.8.20 has been released with the new GPT 5.4 mini/nano aliases and updated pricing info. Release note: https://substack.com/@jeremychone/note/c-230413138

The test

We ran a real auto-context selection task for production coding.

The model gets:

• A code map file for each source path, with summary, when_to_use, public_types, and public_functions

• The user prompt

• An instruction to select the appropriate paths for that prompt

In this case, the available file set is about 70 files and 8k LOC, so it is relatively small.

This is not an extreme retrieval problem. It is a medium-complexity selection task, the kind of step many coding agents and developer workflows need to get right consistently.

Test setup

We ran the same auto-context task across several model settings:

• mini

• mini-medium

• mini-high

• flash

Each run used the same prompt, the same code map, and the same context files.

The goal was simple: measure the tradeoff between speed, cost, and selection quality for a real auto-context step in a production coding workflow.

The config with pro@coder is as follows:

context_globs:
  - "*.*"
  - src/**/*.*
  - doc/**/*.*
  - dev/spec/*.*
  - tests/**/*.*
  - "!tests/.out/**/*.*" 
  
auto_context: 
  model: mini-medium     
  input_concurrency: 32

dev:
  chat: true 
  plan: false

model: mini

And the prompt is:

Do not write any code file, just read and update dev chat. 

tell me what is missing on the new doc for llm. We added quite a bit the last few weeks.

We changed auto_context.model across mini, mini-medium, mini-high, and flash, cleaning the dev chat for each iteration.

Results

Here are the results for the task, from worst to best:

Note: This is based on a few runs for this particular use case. In practice, medium-complexity tasks like this can still provide a useful relative benchmark.

What the test shows

For this specific auto-context task:

• flash produced the best overall result

• mini was extremely fast, but the quality was too low for this task

• mini-medium improved on mini, but was still not reliable enough

• mini-high got much closer on quality, but with a significant latency cost

The quality gap shows up quickly on this kind of medium-complexity context selection task.

Practical takeaway

If your workflow depends on selecting the right files before the main coding step, this is the kind of benchmark worth tracking.

Auto-context is one of those places where a small quality gap can create a much larger downstream problem. A model that is fast but selects the wrong files does not really save time.

In this test, flash gave the best balance for the task.

We will keep running more variations on the same benchmark and share the results.

Video also available on YouTube (better experience on Mobile)

See below for the asset and prompts.

Image reference: https://www.vecteezy.com/vector-art/4063019-nice-graph-design
(from Gerardo Giuseppe Ramos Granada)

Key Points for #ProductionCoding with AI

✅ Workflows matter more than tools and models.

✅ File-based for scale (e.g., do not code in a chat box)

✅ Use tools that allow you to OWN your context.

The last point is the most important,

👉 For maximum AI coding quality, use CONTEXT LENSING.

Context lensing is about having tight control of what we want the AI to see and not see.

Step 1 - Initial

In the pro@coder prompt, paste the image and use this prompt.

In the web-content/ folder, implement index.html to display the chart shown in the image. 
- Use canvas2d
- Follow the same dot positions as the image
- Chart should take up 2/3 of the page
- Resize with the page and be centered.

![chart](image.png)

Step 2 - Add toolbar and toggle

Implement the toggle toolbar as shown in the image, and implement the bar view.

![chart-with-toggle](image-1.png)

Step 3 - Fix the UI

Position the toolbar so that it overlaps with the top line of the chart and make it larger, as shown in the `chart-with-toggle-reference` image. 
Look at the `actual-chart-implemented` image to see how it currently looks.

![actual-chart-implemented](image-2.png)

![chart-with-toggle-reference](image-1.png)

Step 4 - Number cheating

Now, when in line mode, allow the user to drag the dot vertically and keep the lines connected to it.#AIProductionCoding

#VibeCoding to #AIProductionCoding

Prerequisite

• Install AIPack (to get the aip command line): See https://aipack.ai

• Recommended: Create a new folder and initialize a Git repository with a .gitignore file that ignores .aipack/ and other build files (best practices)

• Recommended: Open this folder in your IDE (e.g., VSCode, Cursor, etc.) and open an integrated terminal

• Install pro@coder with aip install pro@coder

Prompt used in this video:

First Prompt - Create initial index.html

First, implement the following. No plan is needed for this task.

Under the `web-content/` folder, implement a single `index.html` file featuring a particle triangle. This triangle should explode on the first click and then reassemble on the second click.

- Use Canvas2D.
- The canvas should resize with the screen, using a 16px margin.
- Triangle:
    - The triangle should be centered and point upward.
    - The triangle must occupy about two-thirds of the canvas area.
    - Triangle Particles must be 8px by 8px, spaced out by 4px.
    - Use a dark background and blue particles.
- Explosion:
    - The explosion should use `sin easeOutQuint` easing, originate from the center, move outward, and stop 80% of the way and hold this state until the next click triggers reassembly.
    - The explosion should look organic.
- Reassembly: 
    - The reassembly animation should use `easeOutElastic` easing.
    - When reassembled, it should return to the initial state.
- Other requirements: 
    - Ensure that clicks can be registered even during the animation.

Second Prompt - Ask to create the prompt

Following the plan rules, create a plan to refactor this index.html into a proper architecture

- js files under web-content/js/...
- main.js entrypoint, type module 
- cv-utils.js for canvas utilities
- cv-animation.js for animations
- easing.js for easing
- And any other good designed js. 
- Also config.js for holding the config values. 
- css/main.css
- start with the main js css refactor. 

Conclusion

This was a very simple example of how to apply some Pro AI Coding practices even when the start was vibe coded.

Here are some more tips about Vibe Coding to AI Pro Coding

Until next time, happy coding!

Our use case is both simple and impactful: converting approximately 500MB of raw HTML documentation into just 0.5MB of refined, AI-optimized content using the AIPack lab@ako.

Runs in a Terminal User Interface, compatible with Windows, Mac, and Linux, on desktop or cloud.

Your API Key, Your Way, Open source, High power, Zero fluff.

The Demo Walkthrough

We’ll demonstrate how to easily install and set up the lab@ako AI Pack. For this demo, we’re using public documentation from alchemy.com.

Here’s the demo plan:

• Install lab@ako, the Agentic Knowledge Optimization AI Pack deployed on aipack.ai.

• Run lab@ako on a small set of files to understand how the agent processes data and validates outputs.

• Scale the operation by downloading 500MB of raw HTML and increasing concurrency to 32 parallel tasks.

• Watch as 30 minutes of sequential processing is condensed into just 5 minutes of high-concurrency performance.

The Agentic Workflow

The lab@ako agent follows a structured, multi-sub-agent pipeline designed for deep optimization:

1. Fetch & Slim: The process begins by fetching raw documentation files. The agent then “slims” them by stripping away noisy HTML and converting the content into clean Markdown. Each resulting Markdown file includes a concise, AI-generated summary.

2. Clean & Augment: Each Markdown file is refined further—structural issues are fixed, and the content is enhanced to ensure clarity, coherence, and contextual richness for LLM reasoning.

3. Final Indexing: Using the summaries from step one, the AI compiles a comprehensive index file, llm.md. This file serves as a single source of truth for LLMs, enabling fast and precise knowledge retrieval.

In summary, lab@ako transforms 500MB of noisy HTML into 0.5MB of clean, structured, and AI-optimized Markdown, complete with a specialized llm.md index file—ready to power AI systems for accurate and efficient knowledge reasoning.

What’s Next?

Building on the success of lab@ako, we’re preparing to launch lab@kchat, our upcoming Knowledge Chat solution. This next AI Pack will allow users to deploy the kchat agent and begin interacting directly with their optimized content—turning static documentation into an intelligent, conversational knowledge experience.

We'll demonstrate how to use the built-in demo@proof (proofreader) AI Pack, which proofreads a prompt or one or more files.

- 00:00 - Intro
- 00:11 - Setup
- 00:54 - First run of demo@proof with parametric prompt
- 02:14 - Craft Custom Text Example
- 03:23 - Model Reasoning Suffix
- 03:57 - Proof English
- 04:30 - Proof Multiple Files
- 06:05 - Input Concurrency to 3
- 06:53 - AIPACK Base Config
- 08:15 - What Next

You can install AIPACK from https://aipack.ai

And see many videos and tutorials at https://news.aipack.ai/archive

(This video on YouTube)

👉 Live Demo Registration

I’m hosting a hands-on webinar on Wed, 28 May • 11 AM PT where we’ll:

• 150 MB of raw HTML → 0.9 MB of AI-Optimized Markdown

• Strip out menus, ads, and noise (~ 3.5 MB Slimmed HTML, ~ 1.2 MB Raw Markdown)

• Agentic Clean & Augment ⮕ 0.9 MB of clean

• Result ⮕ Highest content-to-noise ratio content

• Do it all with simple AIPACK agents in under few minutes

See you on Wed, 28 May • 11 AM PT

👉 Live Demo Registration

Can’t make it live? Drop a comment below with what you’d most like to see, and we will send you the replay!

First, we’ll do a quick walkthrough of the prerequisites:

• Install AIPACK (the aip command line) from https://aipack.ai

• Start VSCode in a folder and set the desired AI Providers' API Keys

• (optional) Install the optional VSCode AIPACK extension.

Here is the AIPACK-Lab folder for this project.

Then, we will do the hello world example, which has two main sections.

1) Hello World

In the hello world section of the tutorial, we will learn how to:

• Create a simple my-agent.aip with hardcoded input (in the data # Data) and use debug print in the output (# Output) (without AI - good for debugging).

• Activate the # Instruction section to send the request to AI.

• Use multiple inputs from the command line with aip run -i ... -i ....

• Change the model and use the -zero Gemini 2.5 suffix to control the thinking budget.

• Append (aip.file.append) content to a single file for all concurrent inputs.

3) HTML Optimizer

Then, we will update the my-agent.aip tutorial to learn how we can AI optimize an HTML code documentation page using AIPACK slim HTML and markdown API, forwarding the slimmed markdown content to AI to get a small but semantically rich markdown file.

We will use the following AIPACK APIs:

• aip.web.get to get the original HTML content.

• aip.file.save_html_to_slim to slim the original HTML from 1.5MB to 57KB.

• aip.file.save_html_to_md to save the slimmed HTML as markdown (10KB).

• Craft a custom instruction to have gemini-flash-2.5-flash structure and reconstruct the code blocks.

• aip.md.outer_md_block_or_raw to remove any encompassing markdown code block.

Check out all of the AIPACK Lua APIs Documentation for more information.

Feel free to subscribe to AIPACK Substack at news.aipack.com for more info and tutorials.

In this example, I add a feature to AIPACK itself, which has about 20k LOC, and I use the new OpenAI GPT-4.1, but I can switch to any model from the prompt file on a per-request basis.

It took me a while to fully embrace AI for PRODUCTION CODING, as the overwhelming Vibe Coding noise was distracting and frustrating. But once we use AI to code our way, the force multiplier is really exhilarating.

Embrace AI for PRODUCTION CODING Today, your way.

If you want to try AIPACK for production coding,

- you can install AIPACK https://aipack.ai

- See a demo with pro@coder https://news.aipack.ai/p/procoder-ai-pack-demo-generate-doc

• `pro@coder` AI Pack for the code

• Custom dev/pricing AIPACK Agents build the JSON from providers' pricing pages

Note that dev/pricing also uses the same data to generate Rust code, enabling the `aip` binary to compute prices for all models.

It works by using the power of the AIPACK runtime. I started putting my best practices into a pro/Rust10x AI Pack that can be used with the pro/coder AI Pack (

# Install AIPACK
cargo install aipack

# Install the Pro coder & rust10x packs
aip install pro@coder
aip install pro@rust10x

Then, in your project folder you do:

aip run pro@coder

This will create a .aipack/.prompt/pro@coder/coder-prompt.md

Which will be your coder prompt.

Then, in the top toml code block you can replace it with this:

```toml
#!meta - parametric agent block

knowledge_globs = ["pro@rust10x/guide/base/**/*.md"]
base_dir = ""

context_globs = ["Cargo.toml", "src/**/*.rs"] 

model_aliases = {pro = "claude-3-7-sonnet-latest", gpro = "gemini-2.5-pro-exp-03-25", high = "o3-mini-high", low = "o3-mini-low", cheap = "gpt-4o-mini", fast = "gemini-2.0-flash"}

write_mode = true

model = "flash"
```

And then, you can follow the demo.

Obviously, you can have your own best practices. Everything is open source, even those pro packs. You can find the pro packs at:

https://github.com/aipack-ai/packs-pro

You can make your own pack with

aip pack path/to/agent-folder/

More on this later. Comments and like if you want to seem more of those type of content.

Until next time, happy coding!

Step-by-Step Setup

Install AI Pack CLI
Make sure you have Rust installed.

# Install AIPACK (aip command line)
cargo install aipack

# Install pro@coder
aip install pro@coder

This will install the prop@coder aipack at ~/.aipack-base/pack/installed/pro/code

🔑 Check Your API Keys

Ensure your environment has the necessary keys:

aip check-keys

🚀 Run pro@coder

aip run pro@coder

This launches the AI agent with a customizable prompt system. By pro@coder convention, prompts live in:

.aipack/.prompt/pro@coder/coder-prompt.md

🛠️ Configure the Prompt

• The prompt supports parameters via a toml code block.

• Set the model (e.g. gemini2-flash for fast/free or gmini2.5-pro for high quality).

• Write Mode:

  • Set to false to avoid file generation.

  • Set to true to enable the agent to write output files.

📂 Step 1: Generate Per-File Summaries

1. Set Working Globs (for parallel file processing):

...
# context_globs = ...

working_globs = ["web/content/**/*"]
working_concurrency = true
input_concurrency = 6
write = true

1. Prompt Example:

Can you summarize the working files? Save each file's summary in .doc/summary-<normalized-path>.md

1. Run the prompt (e.g., using R inside the ProCoder interface).

✅ Result: Summaries for each source file saved in .doc/.

📘 Step 2: Create a Consolidated Summary

1. Switch to Context Globs:

...

context_globs = [".doc/summary-*.md"]

# working_globs       = ["web-content/**/*.*"]
# working_concurrency = true
# input_concurrency   = 6

1. Prompt Example:

Can you summarize your context files and save the result in doc/summary.md

1. Run again with write = true.

✅ Result: A clean, full summary generated at doc/summary.md.

✨ Highlights

• Tiny Pack: ~9KB binary (pro@coder)

• Offline & Secure: Works with local keys, local models, or remote models.

• Highly concurrent: Up to 6 files processed at once.

• Any AI Models/Providers: Gemini, OpenAI, Anthropic, Ollama, Groq, xAI

• Production Practices: Modular, guided prompts and output control.

🧠 Pro Tips

• Use working globs for parallel processing.

• Use context globs for giving an hollistic context (both Working and Context globs can be combined)

• .gitignore Ignore, the `.*` for temporary output.

That’s it! With AI Pack pro@coder, you can turn any codebase into clean, structured documentation in no time, and much more.

Until next time—happy coding!

While this demo is very simple and might fall into the "snake game" AI coding category, it demonstrates the flexibility of the JC Coder pack—which I am using to code AIPACK itself and other production projects.

Video chapters:

• 00:00 - AIPACK installation and initialization

• 00:10 - Install and run jc coder pack

• 00:37 - Creating the initial Pong game

• 02:34 - Refactor 1 – Separating JS and CSS into their own files

• 03:24 - Refactor 2 – Using the type module and splitting JS files

• 04:47 - Adding Particle explosion

• 06:07 - The final result

Check out aipack.ai and subscribe to this Substack for more updates:

AIPACK Substack

News, insights, and applications of Agentic Runtimes and AIPACK.

By Jeremy Chone

Key Concepts for the jc@coder Pack:

• Works with any IDE, as it is just a command line tool (Tip: map "cmd + r" to send 'r' to the terminal).

• File-based – the prompt is a single Markdown file, with the top section containing the instructions and the bottom containing the AI response. So, no copy/paste code into the terminal or get lost in chats.

• Fully parametric – thanks to AIPACK parametric agent support, JC Coder allows the prompt to customize the model, knowledge/source context files, and even concurrency and temperature.

• AI response info – returns usage and cost details in the prompt file.

• The JC Coder AIPACK is extremely small (currently under 8 KB zipped) and implements all of the agent coding logic.

• Once installed, the JC Coder Pack can be found at ~/.aipack-base/pack/installed/jc/coder. For very advanced users, it can be copied into your ~/.aipack-base/pack/custom/my/coder directory so that you can customize it and run it with aip run my@coder.

Key Concepts/Benefits for AIPACK:

• AIPACK is built with Rust, ensuring efficiency and high concurrency.

• It leverages the Rust genai crate, which supports all major AI providers and models.

• AIPACK is an agentic runtime offering a multi-stage, Markdown-based model and Lua as the efficient embedded scripting language, providing full flexibility and simplicity.

• AIPACK features an innovative parametric agent model that allows agents to extract deterministic parameters directly from the prompt—or even from the AI response.

• AIPACK is designed for concurrency, allowing agent packs like JC Coder to parallelize agent tasks across multiple input files (demo video coming).

• AIPACK can run any multi-stage agent Markdown file using a command like: aip run path/my-agent-aip

• It can also pack, install, and run AI Packs whenever users are ready to share their agents.

• See intro video at

Subscribe to this Substack for news and updates about AIPACK. It's just the beginning – things are about to pick up speed, thanks to AIPACK.

Until next time – happy running!

• It supports all major AI Providers and Models.

• It's efficient and small, below 20 megabytes with zero dependencies.

• It can be run locally, completely IDE Agnostic, or in the cloud, server, or serverless.

So, what is an AI PACK?

An AIPack is a .aipack cross-platform file that can be installed, run, built, and shared.

An AIPack file contains:

• Agents: One or More Agent Files, the .aip multi-stage markdown file.

• Logic: Any number of Lua files, which provide a very efficient and cross-platform way to add logic to our agent.

• Data: Any type of data from markdown, JSON, CSV, and even later SQLite data.

An AI Pack agent is a single .aip file defined within a multi-stage markdown file.

There are three main stages:

1. The first stage is the data stage, which contains the logic to fetch and prepare the data for the prompt.

2. The prompt templating stage gives complete control over the prompt layout using the data from the previous stage. This is what will get sent to the AI Model.

3. The AI Model response will be sent to the output stage for processing.

The AIPACK Runtime is built to run an agent in parallel when multiple inputs are given, providing full parallelism with minimal complexity.

An agent can define map-reduce stages, including Before All and After All stages, enabling advanced concurrent processing and input reshaping. This provides unparalleled flexibility, concurrency, and simplicity.

You can find more information about AIPACK at aipack.ai

Feel free to subscribe to this Substack for the latest news and updates:

It's just the beginning, but we already have quite a bit working, and new features are coming fast.

Until next time, happy running.