Quiz: AI-Assisted Craft CMS Development

ai-assisted-craft-cms-development.json

{
  "quizzes": [
    {
      "title": "AI-Assisted Craft CMS Development",
      "passingScore": 70,
      "timeLimit": 0,
      "maxAttempts": 0,
      "allowRetakes": 1,
      "showCorrectAnswers": 1,
      "shuffleQuestions": 1,
      "shuffleAnswers": 1,
      "hasGuestAccess": 0,
      "hasFreeAccountAccess": 0,
      "enabled": 1,
      "multipleChoiceQuestions": [
        {
          "questionText": "What is the primary purpose of the CLAUDE.md file?",
          "quizOptions": [
            { "optionText": "It replaces the project's README", "isCorrect": 0 },
            { "optionText": "It gives Claude Code project-specific context so it collaborates instead of guessing", "isCorrect": 1 },
            { "optionText": "It stores API keys for Claude Code authentication", "isCorrect": 0 },
            { "optionText": "It logs all Claude Code interactions for auditing", "isCorrect": 0 }
          ],
          "explanation": "CLAUDE.md gives Claude Code the project-specific context it needs — tech stack, conventions, structure, and patterns — so it can work as a knowledgeable collaborator instead of making generic guesses."
        },
        {
          "questionText": "Which Claude Code command scans your project and generates an initial CLAUDE.md?",
          "quizOptions": [
            { "optionText": "/scan", "isCorrect": 0 },
            { "optionText": "/init", "isCorrect": 1 },
            { "optionText": "/setup", "isCorrect": 0 },
            { "optionText": "/generate", "isCorrect": 0 }
          ],
          "explanation": "The /init command scans your project's composer.json, config files, and directory structure to generate a starting CLAUDE.md document. It's automated reconnaissance — Claude builds an initial understanding without you explaining anything."
        },
        {
          "questionText": "What does the @ syntax do when used in a Claude Code prompt?",
          "quizOptions": [
            { "optionText": "It tags another developer for code review", "isCorrect": 0 },
            { "optionText": "It creates a new file at the specified path", "isCorrect": 0 },
            { "optionText": "It directs Claude's attention to a specific file for focused analysis", "isCorrect": 1 },
            { "optionText": "It adds a file to the git staging area", "isCorrect": 0 }
          ],
          "explanation": "The @filename syntax (e.g., @config/app.php) tells Claude Code to read and focus on that specific file. It's more efficient than asking Claude to 'look at my config files' — you're directing attention, not hoping it finds the right thing."
        },
        {
          "questionText": "In the course's inherited project audit workflow, what is the recommended first step?",
          "quizOptions": [
            { "optionText": "Run all database migrations", "isCorrect": 0 },
            { "optionText": "Update all plugins to the latest versions", "isCorrect": 0 },
            { "optionText": "Run /init for an automated project scan", "isCorrect": 1 },
            { "optionText": "Delete the existing CLAUDE.md and start fresh", "isCorrect": 0 }
          ],
          "explanation": "The 30-minute audit starts with running /init for automated reconnaissance. Claude scans the project and generates a baseline CLAUDE.md, giving you a starting point before you explore deeper with targeted questions."
        },
        {
          "questionText": "What is the key difference between Claude Chat and Claude Code demonstrated in the Feed Me lesson?",
          "quizOptions": [
            { "optionText": "Claude Chat is free while Claude Code requires a subscription", "isCorrect": 0 },
            { "optionText": "Claude Chat explains and provides snippets; Claude Code creates files, runs commands, and iterates on errors", "isCorrect": 1 },
            { "optionText": "Claude Chat is more accurate but slower", "isCorrect": 0 },
            { "optionText": "Claude Code only works with PHP while Claude Chat supports all languages", "isCorrect": 0 }
          ],
          "explanation": "Claude Chat is like a knowledgeable colleague on the phone — it explains well but can't act. Claude Code is that same colleague at your computer — it creates files in the right location, follows your project conventions, runs commands, and sees errors immediately."
        },
        {
          "questionText": "What does Plan Mode actually do when toggled on with /plan?",
          "quizOptions": [
            { "optionText": "It asks Claude to create a project plan document", "isCorrect": 0 },
            { "optionText": "It constrains Claude by preventing all file operations, making it a thinking partner", "isCorrect": 1 },
            { "optionText": "It switches to a more expensive AI model for better results", "isCorrect": 0 },
            { "optionText": "It records the conversation for later review", "isCorrect": 0 }
          ],
          "explanation": "Plan Mode is a real mode toggle, not just a polite request. When active, Claude Code won't write files or execute code — it explores your project and thinks with you. This forces it to be a thinking partner, not a code generator."
        },
        {
          "questionText": "In the Plan Mode lesson, why did Claude surface Google Apps Script as a concern?",
          "quizOptions": [
            { "optionText": "Apps Script is deprecated and shouldn't be used", "isCorrect": 0 },
            { "optionText": "The two-way sync requires code running in Google's environment, which is outside typical Craft developer expertise", "isCorrect": 1 },
            { "optionText": "Apps Script costs more than a PHP-based solution", "isCorrect": 0 },
            { "optionText": "Craft CMS doesn't support webhook endpoints", "isCorrect": 0 }
          ],
          "explanation": "Google Sheets can't push changes on its own — it needs Apps Script (JavaScript in Google's environment) to detect edits and call webhooks. Plan Mode surfaced this skill gap early, before any code was written, so the developer could plan for it."
        },
        {
          "questionText": "After exiting Plan Mode, what does the course recommend you produce first?",
          "quizOptions": [
            { "optionText": "Working code for the first feature", "isCorrect": 0 },
            { "optionText": "A test suite", "isCorrect": 0 },
            { "optionText": "Saved documentation — the plan, diagrams, and scope documents", "isCorrect": 1 },
            { "optionText": "A new CLAUDE.md file", "isCorrect": 0 }
          ],
          "explanation": "The first output after planning should be documentation, not code. The course teaches telling Claude 'Don't start building yet' after exiting Plan Mode, and instead saving the plan as markdown, a Mermaid diagram, and a contractor scope doc."
        },
        {
          "questionText": "Where do personal Claude skills live so they're available across all your projects?",
          "quizOptions": [
            { "optionText": ".claude/skills/ in the project root", "isCorrect": 0 },
            { "optionText": "~/.claude/skills/", "isCorrect": 1 },
            { "optionText": "config/claude/skills/", "isCorrect": 0 },
            { "optionText": "/usr/local/claude/skills/", "isCorrect": 0 }
          ],
          "explanation": "Personal skills live in ~/.claude/skills/ (your home directory) so they follow you across every project. Project skills live in .claude/skills/ within the project root and are only available in that project."
        },
        {
          "questionText": "How does Claude Code decide whether to load a skill file?",
          "quizOptions": [
            { "optionText": "It loads all skills in the directory every time", "isCorrect": 0 },
            { "optionText": "The user must explicitly invoke skills with a command", "isCorrect": 0 },
            { "optionText": "It matches the task against the skill's description field in the YAML frontmatter", "isCorrect": 1 },
            { "optionText": "It reads the filename and loads skills alphabetically", "isCorrect": 0 }
          ],
          "explanation": "Each skill has a description field in its YAML frontmatter. Claude Code matches your current task against that description to decide whether the skill is relevant. If the description is too vague, the skill won't load when needed."
        },
        {
          "questionText": "How do you create a custom Claude Code command called /audit?",
          "quizOptions": [
            { "optionText": "Register it in config/app.php", "isCorrect": 0 },
            { "optionText": "Create a file at .claude/commands/audit.md", "isCorrect": 1 },
            { "optionText": "Run /register audit", "isCorrect": 0 },
            { "optionText": "Add it to the CLAUDE.md commands section", "isCorrect": 0 }
          ],
          "explanation": "Custom commands are markdown files in .claude/commands/. The filename becomes the command name, so audit.md becomes /audit. The file content is the prompt that runs when the command is invoked."
        },
        {
          "questionText": "What does the $ARGUMENTS placeholder do in a custom command file?",
          "quizOptions": [
            { "optionText": "It defines required parameters that must be provided", "isCorrect": 0 },
            { "optionText": "It captures whatever text the user types after the command name", "isCorrect": 1 },
            { "optionText": "It lists the command's supported flags", "isCorrect": 0 },
            { "optionText": "It references environment variables", "isCorrect": 0 }
          ],
          "explanation": "$ARGUMENTS lets users customize command behavior at runtime. For example, '/audit focusing on Commerce setup' passes that context into the command prompt, letting the same base command serve different situations."
        },
        {
          "questionText": "Why did the course recommend using Plan Mode for the two-way Google Sheets sync but not for a simple template edit?",
          "quizOptions": [
            { "optionText": "Plan Mode only works with complex file structures", "isCorrect": 0 },
            { "optionText": "Plan Mode requires a paid subscription for simple tasks", "isCorrect": 0 },
            { "optionText": "Plan Mode is valuable when entering unfamiliar territory or crossing system boundaries, not for isolated changes", "isCorrect": 1 },
            { "optionText": "Simple template edits can't be planned in advance", "isCorrect": 0 }
          ],
          "explanation": "Plan Mode shines when building features that cross system boundaries or require unfamiliar skills. For simple, isolated changes — adding a field, tweaking a template — your own experience is the plan. Use it when the cost of discovering problems mid-build is high."
        },
        {
          "questionText": "What command shows you which skills Claude Code currently has loaded?",
          "quizOptions": [
            { "optionText": "/list", "isCorrect": 0 },
            { "optionText": "/context", "isCorrect": 0 },
            { "optionText": "/skills", "isCorrect": 1 },
            { "optionText": "/status", "isCorrect": 0 }
          ],
          "explanation": "The /skills command shows exactly what Claude Code is working with. It's the first debugging step if you suspect a skill isn't being loaded — check whether it's actually active."
        },
        {
          "questionText": "Which statement best captures the course's philosophy about AI-assisted development?",
          "quizOptions": [
            { "optionText": "AI will replace the need for developers to understand their tools", "isCorrect": 0 },
            { "optionText": "AI is a collaborator that needs proper context and human oversight to be effective", "isCorrect": 1 },
            { "optionText": "AI tools should only be used by senior developers", "isCorrect": 0 },
            { "optionText": "AI-generated code should be deployed without review to save time", "isCorrect": 0 }
          ],
          "explanation": "The course emphasizes that AI isn't magic — it's a collaborator requiring proper setup (CLAUDE.md), context (skills), and human judgment (overriding suggestions like unnecessary defensive code). Developers stay in control."
        }
      ],
      "trueFalseQuestions": [
        {
          "questionText": "CLAUDE.md should be created once and never updated after initial setup.",
          "correctAnswer": 0,
          "explanation": "CLAUDE.md evolves with the project. You should document new plugins, configuration quirks, and common mistakes as you discover them. It becomes living documentation that makes Claude Code more effective over time."
        },
        {
          "questionText": "The /init command produces a perfect CLAUDE.md that should be accepted without review.",
          "correctAnswer": 0,
          "explanation": "The course emphasizes reviewing what /init generates — it catches basics like your tech stack and plugins, but it won't know your conventions, coding standards, or established patterns. You refine it manually."
        },
        {
          "questionText": "When Claude Code suggests defensive code you know is unnecessary for your use case, you should always keep it because AI knows best.",
          "correctAnswer": 0,
          "explanation": "The course teaches that humans stay in control. In the Feed Me lesson, Claude suggested an unnecessary $event->isNew check. If you understand your context better than Claude — like knowing the import is configured for 'add new only' — you should override the suggestion."
        },
        {
          "questionText": "Plan Mode prevents all file operations, not just writing code.",
          "correctAnswer": 1,
          "explanation": "Plan Mode blocks everything that modifies files — Claude can't save a markdown document any more than it can write a PHP class. That's by design: Plan Mode is purely for thinking, with no side effects. You must exit Plan Mode before Claude can save anything."
        },
        {
          "questionText": "Project commands stored in .claude/commands/ can be committed to version control and shared with your team.",
          "correctAnswer": 1,
          "explanation": "Project commands live in the project directory and can be version controlled. When a colleague pulls, they have the command too. This turns processes like project audits into documented, consistent, shared workflows."
        },
        {
          "questionText": "Custom commands and skills need to be perfect before you start using them.",
          "correctAnswer": 0,
          "explanation": "The course emphasizes iteration for both commands and skills. Use them, notice what's missing, refine, repeat. Commands evolve through actual use — the one you write today won't be the same one you have in a month."
        },
        {
          "questionText": "The course's 30-minute inherited project audit workflow starts by reading every file in the codebase.",
          "correctAnswer": 0,
          "explanation": "The audit starts with /init for an automated scan, then uses targeted @ file references and directed questions to build understanding incrementally. You don't try to understand everything at once — each answer informs your next question."
        },
        {
          "questionText": "The course positions itself as evangelism, trying to convince developers to start using AI tools.",
          "correctAnswer": 0,
          "explanation": "The course explicitly states that 80% of developers already use AI tools. It's about doing it better and more professionally — not convincing anyone to start. No hype, no magic — just a professional workflow."
        }
      ]
    }
  ]
}