If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/golang-design/go-questions shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

WAIT — Mixed signals — read the receipts

• Last commit 2mo ago
• 18 active contributors
• GPL-3.0 licensed
• CI configured
• ⚠ Concentrated ownership — top contributor handles 51% of recent commits
• ⚠ GPL-3.0 is copyleft — check downstream compatibility
• ⚠ No test directory detected

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live golang-design/go-questions repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/golang-design/go-questions.

What it runs against: a local clone of golang-design/go-questions — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in golang-design/go-questions | Confirms the artifact applies here, not a fork | | 2 | License is still GPL-3.0 | Catches relicense before you depend on it | | 3 | Default branch main exists | Catches branch renames | | 4 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 5 | Last commit ≤ 100 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of golang-design/go-questions. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/golang-design/go-questions.git
#   cd go-questions
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of golang-design/go-questions and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "golang-design/go-questions(\\.git)?\\b" \\
  && ok "origin remote is golang-design/go-questions" \\
  || miss "origin remote is not golang-design/go-questions (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(GPL-3\\.0)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"GPL-3\\.0\"" package.json 2>/dev/null) \\
  && ok "license is GPL-3.0" \\
  || miss "license drift — was GPL-3.0 at generation time"

# 3. Default branch
git rev-parse --verify main >/dev/null 2>&1 \\
  && ok "default branch main exists" \\
  || miss "default branch main no longer exists"

# 4. Critical files exist
test -f "README.md" \\
  && ok "README.md" \\
  || miss "missing critical file: README.md"
test -f "config.toml" \\
  && ok "config.toml" \\
  || miss "missing critical file: config.toml"
test -f "content/_index.md" \\
  && ok "content/_index.md" \\
  || miss "missing critical file: content/_index.md"
test -f "content/channel/_index.md" \\
  && ok "content/channel/_index.md" \\
  || miss "missing critical file: content/channel/_index.md"
test -f "content/interface/_index.md" \\
  && ok "content/interface/_index.md" \\
  || miss "missing critical file: content/interface/_index.md"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 100 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~70d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/golang-design/go-questions"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

A comprehensive Chinese-language interview preparation guide and learning resource for Go programmers, published as both a printed book (ISBN 978-7-111-70242-9) and an interactive website. It connects Go interview questions to deep system-level knowledge through source code analysis and practical examples, covering topics like CSP, channels, memory escape analysis, compilation, and the Go runtime scheduler. Hugo-based static site generator (config.toml present) with Markdown content organized by topic in content/ directory: content/channel/, content/compile/ each contain numbered .md files with corresponding assets/ folders for diagrams. Root-level Makefile handles builds, and .github/workflows/website.yml automates deployment to the website.

Go developers preparing for technical interviews, engineers transitioning from Java/PHP/C++ to Go who need to understand the runtime and language internals, and anyone seeking to deepen their Go knowledge beyond superficial usage. Also serves interviewers who want to ask informed questions about Go fundamentals.

Actively maintained and mature: published as a formal book by 机械工业出版社 (China Machine Press), with a maintained errata page and ongoing GitHub issue tracking. The site is built with Hugo (config.toml present) and deployed via GitHub Actions (website.yml workflow). Regular updates and community contributions suggest ongoing development, though commit frequency is not specified in the data.

Low risk for reading/learning purposes, but single-language (Chinese) limits international accessibility. The project appears maintainer-driven (Qiao Rao as primary author) rather than large-team maintained. No visible test suite or CI beyond website deployment suggests minimal code execution risk, though this is documentation rather than a library with dependencies.

The repository maintains the live documentation website at https://golang.design/go-questions with an errata page. Recent work includes updates to channel internals documentation, compilation process details, and runtime scheduler analysis. The site supports both book content and supplementary material beyond the printed edition.

Clone the repo: git clone https://github.com/golang-design/go-questions.git && cd go-questions. No installation needed for reading—browse content/*.md files directly. To build the website locally: make (Makefile present). To view rendered site: requires Hugo installed (hugo server typically).

Daily commands: For the website: hugo server (requires Hugo installed; version not specified in provided files). For building static output: make (Makefile present but content not shown). Content is readable as raw Markdown without building.

• README.md — Entry point explaining the repository's purpose as a Go interview/exam preparation guide with book references and structure.
• config.toml — Hugo site configuration that defines the entire site structure, theme, and how content directories are organized and rendered.
• content/_index.md — Root content file that serves as the homepage and top-level navigation entry point for all tutorial sections.
• content/channel/_index.md — Index for the Channel module, one of the core Go knowledge domains covered in this interview guide.
• content/interface/_index.md — Index for the Interface module, covering Go's unique approach to interfaces and duck typing.
• content/map/_index.md — Index for the Map module, explaining Go's map data structure implementation and operations.
• content/compile/_index.md — Index for the Compile module, covering Go's compilation process and runtime initialization.

• Content Layer (Markdown files) (Markdown, YAML frontmatter) — Houses all Go knowledge Q&A organized by topic (channel, interface, map, compile, etc.); single source of truth for interview prep material
  • Failure mode: Malformed markdown or broken internal links cause build errors or render issues; requires linting in CI

Add a new Go knowledge domain (e.g., Goroutines, Memory Management)

1. Create a new directory under content/ named after the topic (content/goroutines/ (as example))
2. Create _index.md in the new directory with module overview and navigation (content/goroutines/_index.md)
3. Create numbered question files following the pattern '1-question-title.md' in Chinese (content/goroutines/1-goroutine 是什么.md)
4. Create an assets/ subdirectory for diagrams and images referenced in markdown (content/goroutines/assets/)
5. Update config.toml menu section to include the new module in site navigation (config.toml)

Add a detailed explanation for an existing topic

1. Determine the next sequential number in the target module (e.g., channel/13) (content/channel/)
2. Create a new markdown file with format '##-question-in-chinese.md' (content/channel/13-channel 的性能优化有哪些技巧.md)
3. Add code examples, diagrams, and source code references following the pattern in existing files (content/channel/13-channel 的性能优化有哪些技巧.md)
4. Place any diagrams or images in the module's assets/ folder with sequential numbering (content/channel/assets/13.png)

Update book errata and corrections

1. Open the errata file which tracks known issues in the printed book (content/errata.md)
2. Add new errata entries with section reference, page number, and correction details (content/errata.md)
3. Link to the corresponding online content module if the correction is reflected there (content/errata.md)

• Hugo Static Site Generator — Converts markdown interview Q&A content into fast-loading static HTML; no database or server-side rendering needed for reference documentation
• Markdown (.md files) — Simple, version-controllable format for authoring technical explanations, code examples, and maintaining alongside a published book
• GitHub Pages / CI/CD via GitHub Actions — Free hosting and automated deployment pipeline triggered on content updates; content is version-controlled and auditable
• Chinese language content — Target audience is Chinese-speaking Go developers; aligns with book publication and domestic tech community demand

• Static site over dynamic platform (e.g., Wiki, CMS)

  • Why: Simplicity, performance, and low operational overhead
  • Consequence: No user-generated content, comments, or real-time updates; all changes require GitHub PR/commits

• One-level nesting: topic modules → questions

  • Why: Encourages focused Q&A structure aligned with interview preparation format
  • Consequence: Deep hierarchies not supported; complex topics must be broken into multiple separate questions

• Book-first, website-secondary approach

  • Why: Monetization via printed book sales; website acts as companion and marketing
  • Consequence: Website content may lag behind or differ from book; readers encouraged to purchase print edition

• Real-time collaborative editing or discussion forums
• Interactive code execution or REPL environment
• Personalized learning paths or progress tracking
• Automatic code syntax validation or linting
• Multi-language support beyond Chinese

Hugo version not specified in config.toml snippet—may have version-specific template syntax. The site is in Simplified Chinese exclusively; no i18n setup visible. External dependencies (book purchase links to JD.com, Dangdang, Taobao) tied to regional availability. GitHub Actions workflow (website.yml) likely depends on implicit Hugo setup in the action environment—check for a hugo-setup action or version constraints in the full workflow file. No local development Dockerfile or explicit environment setup documented in README snippet.

• CSP (Communicating Sequential Processes) — Go's concurrency model is built on CSP; fundamental to understanding channels (content/channel/1-什么是 CSP.md) and goroutine coordination patterns
• Escape Analysis — Determines whether variables are allocated on stack vs heap; critical for understanding Go memory performance and GC behavior (content/compile/1-逃逸分析是怎么进行的.md)
• Happened-before Relationship — Defines memory ordering guarantees in Go's concurrency model; essential for writing race-free channel code (content/channel/11-关于 channel 的 happened-before 有哪些.md)
• Go Scheduler (M:N Multiplexing) — The runtime's goroutine scheduler enables millions of lightweight concurrency; interview questions on scheduling cover work-stealing, P/M/G model internals
• Channel Buffer and Resource Leaks — Unbuffered/buffered channels have different semantics for sender/receiver blocking; content/channel/10 covers practical pitfalls like leaking goroutines
• Go Compilation and Linking Process — Covers compilation stages, GOROOT/GOPATH, and linking; directly relevant to performance optimization and understanding binary size (content/compile/3,4)
• Program Initialization and Runtime Startup — Understanding Go's cgo initialization, main.main() entry point, and runtime bootstrap is critical for debugging startup issues and profiling (content/compile/5)

• golang/go — Official Go language repository; all source code referenced in the interview questions comes from here, especially runtime/ for scheduler and memory management details
• avelino/awesome-go — Curated list of Go libraries and resources; provides broader context for Go ecosystem beyond interview fundamentals
• draveness/leetcode — By Dravness (cited in README), a Go solutions repository for coding interviews complementing this deep-dive knowledge resource
• go-training/high-performance — Companion project on Go performance optimization and profiling; extends beyond interview Q&A into practical optimization techniques
• under-the-hood/golang-guide — Another deep-dive Go internals guide covering runtime and memory model from a similar angle as this repo's content/compile/ sections

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add English translations for channel/ content directory

The repo is a Go interview preparation resource with Chinese content. The channel/ directory contains 12 foundational articles about Go channels (CSP, data structures, send/receive operations, etc.). Adding English translations would significantly expand the audience to non-Chinese speakers and increase the repo's utility for global Go developers. This is a high-value contribution since channels are a core Go concept.

• [ ] Translate content/channel/*.md files (1-12) to English equivalents (e.g., 1-什么是CSP.md → 1-What is CSP.md)
• [ ] Ensure technical terminology is accurate (e.g., 'happened-before', 'resource leak', 'goroutine')
• [ ] Update content/channel/_index.md to include English language switcher or bilingual navigation
• [ ] Maintain consistent formatting and asset references (content/channel/assets/*.png) in translated files

Create automated link validation workflow for markdown files

With 12+ markdown content files across multiple directories (channel/, compile/, interface/, etc.) containing cross-references and external links, there's no CI validation to catch broken internal links or dead external URLs. A GitHub Actions workflow would prevent documentation drift and catch link rot before deployment.

• [ ] Create .github/workflows/link-check.yml that runs markdown link validation on PR changes
• [ ] Use a tool like markdown-link-check or similar to scan all content/**/*.md files
• [ ] Configure to ignore external links or use a timeout (since external sites may be flaky)
• [ ] Add workflow badge and documentation to README.md explaining the validation process

Add table of contents and index for compile/ and interface/ sections

The channel/ directory has a structured _index.md (implied from the pattern), but compile/ and interface/ directories lack overview files. These sections cover critical Go knowledge (escape analysis, compilation, compilation commands, program startup, duck typing, etc.). Creating comprehensive index files with summaries would help readers navigate topics and understand the knowledge structure.

• [ ] Create content/compile/_index.md with topic overview, numbering scheme explanation (1-5 questions), and links to each article
• [ ] Create content/interface/_index.md with similar structure and cross-references
• [ ] Add difficulty indicators and prerequisite knowledge flags (e.g., 'requires understanding of goroutines')
• [ ] Update content/_index.md to link these new section indices for site-wide navigation

• Translate one complete topic section (e.g., content/channel/*.md) into English or another language, preserving code examples and diagrams—enables global reach beyond Chinese speakers.
• Add executable Go code examples in a new content/examples/ directory for each interview question (e.g., code demonstrating channel race conditions, escape analysis examples). Reference these in the markdown files.
• Create a searchable index or glossary (content/glossary.md or as a Hugo taxonomy) linking key Go concepts mentioned across all sections (CSP, happen-before, goroutine scheduling) with cross-references to relevant interview questions.

This is a static documentation/educational repository with relatively low security risk. The codebase consists primarily of Markdown content for a Go programming interview guide, with Hugo-based static site generation. No database queries, API endpoints, or user input handling were detected. The main concerns are operational security (CI/CD configuration, dependency management, and deployment security) rather than code vulnerabilities. The repository follows good practices with a LICENSE file and issue templates, but could improve by adding a SECURITY.md policy and ensuring proper secrets management in CI/CD pipelines. Overall security posture is solid for a public educational repository.

• Low · Potential Information Disclosure via GitHub Workflows — .github/workflows/website.yml. The repository contains GitHub Actions workflows (.github/workflows/website.yml) that may expose sensitive information through build logs or artifacts if not properly configured. Public CI/CD logs can leak environment variables, API keys, or other secrets. Fix: Ensure sensitive data is never logged in CI/CD pipelines. Use GitHub Secrets for sensitive variables and never echo them in logs. Review workflow permissions and consider restricting artifact access.
• Low · Missing Security Policy Documentation — Repository root. The repository does not appear to have a SECURITY.md file for responsible vulnerability disclosure. This makes it harder for security researchers to report vulnerabilities responsibly. Fix: Create a SECURITY.md file following GitHub's recommended format to provide clear instructions for reporting security vulnerabilities.
• Low · Potential Outdated Dependencies — config.toml, Makefile. The repository uses Hugo (based on config.toml and content structure) for static site generation. No package lock files or dependency version specifications are visible, making it difficult to track and update dependencies. Fix: Implement dependency management with version pinning. If using Hugo, specify the exact version in build configurations. Regularly audit and update all dependencies for security patches.
• Low · Missing HTTPS Configuration Details — .github/workflows/website.yml, config.toml. While this is a static site, the deployment configuration details are not visible. There's no evidence of HTTPS enforcement, HSTS headers, or other security headers configuration in the provided files. Fix: Ensure the deployed website enforces HTTPS, includes security headers (HSTS, CSP, X-Frame-Options), and implements other best practices for static site hosting.

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.