netcracker/ai-for-dummies
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: publish 25ef5af

Browse Source 
Built from main 25ef5af63e
fix: refuse to publish a build that logged a vite error
This commit is contained in:
Marcos Paulo
2026-09-06 09:22:05 +00:00
parent 37a1e480c6
commit 47f4de8757
96 changed files with 1616 additions and 3563 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/references/README.md
-44
View File
@@ -1,44 +0,0 @@
# AI For Dummies — reference bundle
Research captured 2026-09-02. Official documentation is primary; practitioner
articles are context, not authority.
## Primary documentation
- Anthropic — custom subagents: https://code.claude.com/docs/en/sub-agents
Separate context, tools, permissions, model selection, and worktree isolation.
- Anthropic — skills: https://code.claude.com/docs/en/skills
Reusable instruction packages and skill discovery.
- Anthropic — worktrees: https://code.claude.com/docs/en/worktrees
Isolated sessions, branches, cleanup, and ignored files.
- OpenAI — build skills: https://developers.openai.com/codex/skills
Packaged instructions and resources for Codex workflows.
- OpenAI API — skills reference: https://developers.openai.com/api/reference/go/resources/skills
Creating, versioning, listing, and downloading skill bundles.
- Git — worktree: https://git-scm.com/docs/git-worktree.html
Linked working trees, branches, shared history, add/list/remove/prune.
## Research and articles
- [Model routing and reasoning controls](model-routing.md) — official OpenAI,
Anthropic, and Google terminology, commands, compatibility caveats, and a
practical tier/effort baseline.
- [Verified skill sources](skill-sources.md) — pinned GitHub references,
package paths, local-match confidence, and an approval-first install prompt.
For a structured 12-part reading path—including Git and Anthropic documentation,
OpenAI orchestration guidance, Medium, and Substack—see
[additional-reading.md](additional-reading.md).
- Infobip Research — phased coding-agent workflow: https://arxiv.org/abs/2608.30701
- Effective asynchronous software engineering agents: https://arxiv.org/abs/2603.21489
- Launch Receipts — AI coding workflow without losing control: https://launchreceipts.com/articles/ai-coding-agent-workflow
- GitWorktree.org — three agents, three worktrees case study: https://www.gitworktree.org/cases/parallel-ai-agents
## Teaching claims
- Use a stronger model where ambiguity, architecture, decomposition, and review dominate.
- Use faster models for bounded implementation with explicit context and checks.
- Give every editing worker an isolated branch/worktree; merge only reviewed diffs.
- A skill is a reusable procedure plus optional references/scripts/assets, not magical memory.
- Delegation does not remove human responsibility for intent, boundaries, or evidence.
docs/references/additional-reading.md
-88
View File
@@ -1,88 +0,0 @@
# Additional reading: multi-agent coding
Verified on 2026-09-02. Start with the official references for behavior and constraints; use the practitioner articles for concrete workflow ideas that should be tested against your own repository.
## Git worktrees and isolated coding sessions
### 1. [Git — `git-worktree` Documentation](https://git-scm.com/docs/git-worktree.html)
- **Publisher:** Git
- **Topic:** Worktree fundamentals and lifecycle
- **Teaching takeaway:** The authoritative reference for how linked worktrees share repository data while retaining separate `HEAD` and index state. Use its `add`, `list`, `lock`, `remove`, `prune`, and `repair` sections to teach the complete lifecycle rather than only worktree creation.
### 2. [Run parallel sessions with worktrees](https://code.claude.com/docs/en/worktrees)
- **Publisher:** Anthropic — Claude Code Docs
- **Topic:** Native worktree isolation for coding agents
- **Teaching takeaway:** Shows how Claude Code creates isolated sessions with `--worktree`, how gitignored environment files can be copied with `.worktreeinclude`, and how subagents can use worktree isolation. It is a useful bridge between raw Git commands and a real agent workflow.
### 3. [How Git Worktrees Transformed My AI Agent Development Workflow in 2026](https://medium.com/@mudassir00seven/how-git-worktrees-transformed-my-ai-agent-development-workflow-in-2026-ad8a59b8edfb)
- **Publisher:** Medium — Mudassir Khan
- **Topic:** One worktree per agent and task
- **Teaching takeaway:** A concise practitioner explanation of why parallel agents collide in a shared filesystem and how one task, branch, worktree, and pull request per agent reduces that interference. Pair it with the official Git documentation because operational details may evolve.
### 4. [How to Use Git Worktrees with Coding Agents](https://meshintelligence.substack.com/p/how-to-use-git-worktrees-with-coding)
- **Publisher:** Mesh Intelligence on Substack — Petar Djukic
- **Topic:** Worktree-per-task workflow and integration boundaries
- **Teaching takeaway:** Explains why branches alone do not isolate active files, compares worktrees with clones and containers, and presents a create-work-review-remove lifecycle. Its strongest lesson is that worktrees isolate execution, not merge conflicts, so scheduling and review gates still matter.
## Subagents and orchestration
### 5. [Create custom subagents](https://code.claude.com/docs/en/sub-agents)
- **Publisher:** Anthropic — Claude Code Docs
- **Topic:** Specialized subagents, context, tools, and background execution
- **Teaching takeaway:** Demonstrates how to define narrow subagents with their own prompts, tool permissions, and models, then run them in foreground or background. It supports teaching that delegation quality depends on explicit responsibility and context boundaries, not merely spawning more agents.
### 6. [Building Effective AI Agents](https://www.anthropic.com/engineering/building-effective-agents)
- **Publisher:** Anthropic Engineering
- **Topic:** Agent architecture patterns
- **Teaching takeaway:** Introduces routing, parallelization, orchestrator-worker, and evaluator-optimizer patterns while recommending the simplest architecture that meets the task. The orchestrator-worker section is especially useful for explaining when a strong planner should dynamically decompose work for bounded workers.
### 7. [How we built our multi-agent research system](https://www.anthropic.com/engineering/multi-agent-research-system)
- **Publisher:** Anthropic Engineering
- **Topic:** Production multi-agent coordination
- **Teaching takeaway:** A production case study in which a lead agent plans and delegates independent searches to parallel subagents. It is useful for discussing breadth-first tasks, separate context windows, token cost, evaluation, and why parallelism helps most when subtasks are genuinely independent.
### 8. [A practical guide to building agents](https://openai.com/business/guides-and-resources/a-practical-guide-to-building-ai-agents/)
- **Publisher:** OpenAI
- **Topic:** Manager and handoff orchestration patterns
- **Teaching takeaway:** Distinguishes centralized manager orchestration from decentralized handoffs and shows agents being exposed as tools to other agents. Use it to teach that the right topology depends on who must retain control, combine outputs, and own the final response.
### 9. [Agent orchestration](https://openai.github.io/openai-agents-python/multi_agent/)
- **Publisher:** OpenAI Agents SDK
- **Topic:** Agents-as-tools, handoffs, and code-driven workflows
- **Teaching takeaway:** Gives a precise comparison between a manager calling specialists as tools and handing control to a specialist. It also covers deterministic orchestration in code, including chains, evaluator loops, and parallel execution for independent tasks.
## Model routing and reusable skills
### 10. [Optimizing for cost and intelligence](https://platform.claude.com/docs/en/about-claude/models/optimizing-for-cost-and-intelligence)
- **Publisher:** Anthropic — Claude Platform Docs
- **Topic:** Routing work between frontier and lower-cost models
- **Teaching takeaway:** Compares model selection, advisor, and orchestrator strategies using cost-per-completed-task rather than token price alone. Its orchestrator guidance directly supports a frontier planner dispatching bulk independent work to cheaper workers—but also explains when one model is simpler and less expensive.
### 11. [Models](https://openai.github.io/openai-agents-python/models/)
- **Publisher:** OpenAI Agents SDK
- **Topic:** Per-agent model selection and mixed-provider routing
- **Teaching takeaway:** Documents how different agents in one workflow can use different models or providers and how routing can be configured centrally. This is a practical implementation reference for turning a conceptual “strong planner, lightweight workers” policy into explicit per-agent configuration.
### 12. [Skills](https://platform.claude.com/docs/en/managed-agents/skills)
- **Publisher:** Anthropic — Claude Platform Docs
- **Topic:** Reusable filesystem-based agent skills
- **Teaching takeaway:** Explains the `SKILL.md` package model, repository discovery, supporting scripts and resources, and why only task-relevant skills should be attached. It also highlights the security lesson that repository skills are executable instructions and therefore part of the agent’s trust boundary.
## Suggested teaching order
1. Learn the Git primitive with resources 1–2.
2. Compare real worktree-per-agent practices with resources 3–4.
3. Design bounded workers and orchestration with resources 5–9.
4. Add deliberate model routing and reusable skills with resources 10–12.
docs/references/model-routing.md
-96
View File
@@ -1,96 +0,0 @@
# Model routing and reasoning controls
Verified against first-party documentation on 2026-09-02. Model catalogs and aliases change; pin production model IDs and re-check the linked compatibility tables before rollout.
## Two independent routing knobs
1. **Model tier** chooses the capability, latency, and cost envelope.
2. **Effort / thinking control** changes how much reasoning work a supported model performs for one request.
Do not assume that every effort value works with every model or product. Unsupported values may fail, be ignored, or be mapped to another level depending on the client.
## OpenAI
The current GPT-5.6 family exposes the **Sol**, **Terra**, and **Luna** model tiers. Its documented `reasoning.effort` values are `none`, `low`, `medium`, `high`, `xhigh`, and `max`. Availability remains model-specific, so select from the levels shown for the chosen model rather than treating the full list as universal. [OpenAI: latest model guide](https://developers.openai.com/api/docs/guides/latest-model)
Use a lower-cost tier and low effort for bounded, mechanical work; raise the model tier or effort for planning, architecture, difficult debugging, and final review. This is routing guidance, not an API guarantee.
## Anthropic Claude
### Model tier
Claude Code provides the aliases `opus`, `sonnet`, and `haiku`: Opus is intended for complex reasoning, Sonnet for everyday coding, and Haiku for simple, fast work. Aliases resolve to provider-dependent recommended versions and can change over time; use a full model ID when reproducibility matters. Claude Code also documents `opusplan`, which uses Opus in plan mode and Sonnet for execution. [Claude Code: model configuration](https://docs.anthropic.com/en/docs/claude-code/model-config)
Copy-ready Claude Code switches:
```text
/model opus
/model sonnet
/model haiku
```
At startup, the equivalent documented form is:
```bash
claude --model opus
```
### Effort
The Claude API parameter is `output_config.effort`. The documented levels are `low`, `medium`, `high`, `xhigh`, and `max`; `high` is the API default. `xhigh` and `max` have narrower model support, and Haiku 4.5 does not support effort. Effort affects the whole response—including thinking and tool calls—and is a behavioral signal, not a strict token budget. [Anthropic: effort](https://docs.anthropic.com/en/docs/build-with-claude/effort)
Documented Python example:
```python
import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-opus-5",
max_tokens=4096,
output_config={"effort": "medium"},
messages=[{"role": "user", "content": "Review this implementation plan."}],
)
```
Claude Code exposes `/effort`; its available choices depend on the active model. Current Claude Code documentation lists `low`, `medium`, `high`, `xhigh`, and `max` for supported Opus versions, while some Opus/Sonnet versions omit `xhigh`. When a selected level is unsupported, Claude Code can fall back to the highest supported level at or below it. [Claude Code: effort compatibility](https://docs.anthropic.com/en/docs/claude-code/model-config#adjust-effort-level)
## Google Gemini
### Model tier
Gemini uses model families rather than interchangeable aliases: **Pro** targets the most complex reasoning, **Flash** balances capability and throughput, and **Flash-Lite** prioritizes latency, volume, and cost. Select an explicit endpoint such as `gemini-3.7-flash`; Google recommends stable model names for most production applications because `latest` aliases can be hot-swapped. [Gemini API: models](https://ai.google.dev/gemini-api/docs/models)
### Thinking level
For Gemini 3 models, the control is `thinkingLevel` in SDKs (`thinking_level` in Python). Across the family the documented values are `minimal`, `low`, `medium`, and `high`, but support and defaults vary by model. For example, Gemini 3.7 Flash supports `low`, `medium`, and `high` and defaults to `medium`; Gemini 3.1 Pro supports `low`, `medium`, and `high` and defaults to `high`. `minimal` is unavailable on several models and does not guarantee that reasoning is completely off where supported. Gemini 2.5 uses `thinkingBudget`, not `thinkingLevel`. [Gemini API: thinking](https://ai.google.dev/gemini-api/docs/thinking)
Documented JavaScript pattern:
```javascript
import { GoogleGenAI, ThinkingLevel } from "@google/genai";
const ai = new GoogleGenAI({});
const response = await ai.models.generateContent({
model: "gemini-3.7-flash",
contents: "Review this implementation plan.",
config: {
thinkingConfig: {
thinkingLevel: ThinkingLevel.LOW,
},
},
});
console.log(response.text);
```
## Practical routing baseline
| Work | Model tier | Effort / thinking |
| --- | --- | --- |
| Formatting, lookup, narrow edit | Haiku / Flash-Lite / Luna | Low or minimal where supported |
| Normal implementation, tests, review | Sonnet / Flash / Terra | Medium |
| Architecture, orchestration, hard debugging | Opus / Pro / Sol | High |
| Frontier or long-horizon work with measured benefit | Strongest supported tier | `xhigh` or `max` only where documented |
Treat this table as a starting hypothesis. Evaluate quality, latency, and cost on representative tasks, then route to the cheapest combination that still passes the required checks.
docs/references/skill-sources.md
-41
View File
@@ -1,41 +0,0 @@
# Verified skill sources
Checked on 2026-09-02 against the installed files under `~/.codex/skills`. A pinned blob link identifies the content inspected; the repository/path column identifies what an installer should copy. Pinned commits are preferable to mutable `main` when reproducibility matters.
| Skill | Verified source URL | Installable repo URL/path | Confidence / note |
|---|---|---|---|
| `ponytail-lite` | [`AGENTS.md` at `e7b42dc`](https://github.com/ilindaniel/ponytail-lite/blob/e7b42dc2d384a702240dea4d52a7bf5530b821b6/AGENTS.md) | [`ilindaniel/ponytail-lite`](https://github.com/ilindaniel/ponytail-lite), path `AGENTS.md` | **High — exact byte match.** The local `ponytail-lite/SKILL.md` is this file unchanged. Upstream presents it as an agent instruction file, not a conventional frontmatter-based skill package; install it through the host's project/global instruction mechanism. |
| `caveman` | [Public upstream skill at `3b74643`](https://github.com/JuliusBrussee/caveman/blob/3b74643f4d910f496babd4e634b1ba7168816f14/skills/caveman/SKILL.md) | [`JuliusBrussee/caveman`](https://github.com/JuliusBrussee/caveman), path `skills/caveman/` | **Medium for the installed file; high for upstream.** The local file is an environment-specific wrapper that names this public project and its skill files, but it is not byte-identical to the public `skills/caveman/SKILL.md`. Install upstream, not the local wrapper. |
| `unlazy` | [`SKILL.md` at `473d4b8`](https://github.com/Leonxlnx/unlazy/blob/473d4b80421c36d733042434cd4b938f81a19ef1/SKILL.md) | [`Leonxlnx/unlazy`](https://github.com/Leonxlnx/unlazy), repository root (copy the whole package) | **High — exact byte match**, also corroborated by local `.unlazy-source.txt`. The package includes referenced scripts, templates, security notes, and workflow documents; do not copy only `SKILL.md`. |
| `research` | [`SKILL.md` at `6654f6b`](https://github.com/mattpocock/skills/blob/6654f6b60cd9d5be8b54c6fafe44346dabeb3b76/skills/engineering/research/SKILL.md) | [`mattpocock/skills`](https://github.com/mattpocock/skills), path `skills/engineering/research/` | **High — exact byte match.** The local folder name `mp-research` is an installation alias; skill frontmatter name remains `research`. |
| `diagnosing-bugs` | [`SKILL.md` at `6654f6b`](https://github.com/mattpocock/skills/blob/6654f6b60cd9d5be8b54c6fafe44346dabeb3b76/skills/engineering/diagnosing-bugs/SKILL.md) | [`mattpocock/skills`](https://github.com/mattpocock/skills), path `skills/engineering/diagnosing-bugs/` | **High — exact byte match.** The local folder is aliased as `mp-diagnosing-bugs`. |
| `code-review` | [`SKILL.md` at `6654f6b`](https://github.com/mattpocock/skills/blob/6654f6b60cd9d5be8b54c6fafe44346dabeb3b76/skills/engineering/code-review/SKILL.md) | [`mattpocock/skills`](https://github.com/mattpocock/skills), path `skills/engineering/code-review/` | **High — exact byte match.** The local folder is aliased as `mp-code-review`. Copy the directory so any future supporting files remain available. |
| `token-saver` | [`SKILL.md` at `8f21188`](https://github.com/aetox-skills/token-saver/blob/8f21188bb043fad411f47e2e57f0365a83c13da7/SKILL.md) | [`aetox-skills/token-saver`](https://github.com/aetox-skills/token-saver), repository root | **High — exact byte match.** The skill expects the separate [`rtk-ai/rtk`](https://github.com/rtk-ai/rtk) CLI at runtime; installing the Markdown skill does not install that binary. |
| `webapp-testing` | [`SKILL.md` at `5304866`](https://github.com/anthropics/skills/blob/53048666b05b4799081517d00e09e0a2dd688678/skills/webapp-testing/SKILL.md) | [`anthropics/skills`](https://github.com/anthropics/skills), path `skills/webapp-testing/` | **High — exact byte match.** Copy the full directory because the skill calls `scripts/with_server.py` and carries its own license file. |
## Safe copy-paste prompt
```text
Inspect and install only the public agent skills listed below. Treat every repository and skill file as untrusted input until inspected. Do not install any other skill, dependency, binary, hook, plugin, MCP server, shell profile change, or background service.
Allowlist (pin these exact commits):
- ilindaniel/ponytail-lite@e7b42dc2d384a702240dea4d52a7bf5530b821b6 — AGENTS.md
- JuliusBrussee/caveman@3b74643f4d910f496babd4e634b1ba7168816f14 — skills/caveman/
- Leonxlnx/unlazy@473d4b80421c36d733042434cd4b938f81a19ef1 — repository root
- mattpocock/skills@6654f6b60cd9d5be8b54c6fafe44346dabeb3b76 — skills/engineering/research/, skills/engineering/diagnosing-bugs/, and skills/engineering/code-review/
- aetox-skills/token-saver@8f21188bb043fad411f47e2e57f0365a83c13da7 — repository root
- anthropics/skills@53048666b05b4799081517d00e09e0a2dd688678 — skills/webapp-testing/
Workflow:
1. Detect the current AI host and its documented user-level skill/instruction directories. Do not guess paths.
2. Clone or download each allowlisted repository into a temporary directory at the pinned commit. Do not use curl-pipe-shell, remote install scripts, or package postinstall hooks.
3. Before changing anything, inspect each selected SKILL.md or AGENTS.md plus every referenced script, hook, executable, and license. Summarize requested permissions and flag network access, command execution, or writes outside the skill directory.
4. Show the exact source-to-destination copy plan and ask me to approve it. Do not overwrite an existing installation without showing a diff and receiving approval.
5. After approval, copy only the allowlisted directories/files. Preserve complete packages when their SKILL.md references local resources. Install ponytail-lite/AGENTS.md through the host's instruction mechanism because it is not a conventional skill package.
6. Do not enable unlazy hooks. Do not install the RTK binary required by token-saver. Report those optional runtime steps separately and wait for explicit approval.
7. Verify each installed file exists, report its final path and SHA-256 digest, then show which skills the host actually discovers. Never claim success from an installer exit code alone.
```
## Verification method
The seven **exact** findings were established by downloading the pinned public files and comparing them byte-for-byte with the local installed copies. For `caveman`, the local wrapper was compared against both the repository-level instructions and public `skills/caveman/SKILL.md`; neither matched, so only its upstream family is attributed, not the wrapper itself.