The questions are grouped in three areas: a multi-agent research system, Claude Code in a CI/CD pipeline, and structured data extraction with tool use. After them come a cheat sheet to revise from and the anti-patterns that most wrong options are built on.

• Sample questions
• Cheat sheet
• Anti-patterns
• What helped me pass

Multi-agent research system

Most of these questions use the same scenario: a coordinator agent with four subagents (web search, document analysis, synthesis and a report generator).

Claude Code in CI/CD

Structured extraction and tool use

These questions use a system that extracts information from unstructured documents, validates it against JSON schemas and passes it to downstream systems.

Cheat sheet

The facts I kept coming back to while revising, one line each.

Anti-patterns

Most wrong options aren't random: they are real mistakes that sound reasonable. Learn to spot these and many questions become easy.

1. Teaching tool order with examples

   TrapFew-shot examples or prompt rules to make sure verify_identity runs before process_refund.

   FixA hook or prerequisite check in code that blocks the second call until the first has succeeded.

2. Trusting the model's own confidence

   TrapEscalating when Claude says it is unsure, or filtering findings by a confidence score it reports.

   FixObjective triggers: a missing field, an amount over a limit, a policy gap, an explicit request for a human.

3. Escalating on sentiment

   TrapRouting to a human when the customer sounds angry.

   FixEscalate on what the case needs. An angry customer with a simple problem can still be helped by the agent.

4. Reading the reply to decide when to stop

   TrapEnding the loop when the text says "done", or after a fixed number of turns.

   FixStop on stop_reason == "end_turn". A turn cap is only a safety net.

5. Batching everything to save money

   TrapSending urgent or interactive work to the Batches API for the discount.

   FixBatch only what can wait up to a day. Send the rest to the regular API.

6. A bigger context window for missed details

   TrapSwitching to a model with a larger window when details in a long document get missed.

   FixProcess the document in focused sections, then run one pass that combines the section results.

7. Every tool for every agent

   TrapGiving all agents all tools "for flexibility", including full web search for the synthesis agent.

   FixGive each role its own few tools. For a rare need, add one narrow tool or route it back through the coordinator.

8. Hiding failures

   TrapA failed subagent returns an empty result, so the coordinator can't tell "found nothing" from "couldn't look".

   FixReturn an error with its type, the partial results and whether a retry makes sense.

9. One failure stops everything

   TrapA timeout in one subagent ends the whole workflow and throws away the finished work.

   FixRecover locally where possible. Otherwise report to the coordinator, which can retry, reroute or continue with a noted gap.

10. Required fields to force complete output

    TrapMarking every schema field required so nothing comes back empty.

    FixMake fields nullable where the source may not have the data. An honest null beats an invented value.

11. Prompt rules as security

    TrapA generic fetch_url tool plus "only fetch approved domains" in the prompt.

    FixA narrower tool that checks an allow-list itself, so the rule holds whatever the input says.

12. Guessing between matching records

    TrapA lookup returns two customers and the agent picks the most recent one.

    FixAsk for another identifier, such as an email or order number, before acting.

13. Trusting the overall accuracy number

    TrapCutting human review because accuracy is 97% overall.

    FixCheck accuracy per document type and field first. A small document type can fail badly inside a good average.

14. Resuming on stale results

    TrapResuming a session after the code changed and expecting Claude to notice.

    FixTell it which files changed, or start a new session with a summary of what was found.

The rule behind them all: when something must always happen, enforce it in code (hooks, schemas, stop_reason, allow-lists, explicit triggers), not with a prompt, examples or the model's own judgment.

What helped me pass

• Most questions describe a symptom and ask for the root cause. Ignore answers that add a layer to work around the problem.
• If the model "doesn't know" a format or standard, the answer is usually few-shot examples. If the output must match a structure, it is tool use with a schema.
• Subagents share nothing on their own. The coordinator passes everything, in the prompt.
• Learn the Claude Code CLI flags: -p, --max-turns, --max-budget-usd, --system-prompt and --append-system-prompt, --allowedTools, --permission-mode.

Good luck with your exam.

Wanna thank me? 👇🏼

In Github Actions we can acheive this using actions/attest-build-provenance

1. First add permission to your workflows / re-usable workflows with attestations: write

permissions:
  id-token: write
  contents: read
  attestations: write

(optional) with Maven Builds

need to specify the jar that would be generated during the maven build with exact path. in my case it is target/*.jar We can also add the name to attestation.

    - name: Build with Maven
      shell: bash
      run: mvn --batch-mode --update-snapshots -DskipTests package    

    - name: Attest Artifacts
      uses: actions/attest-build-provenance@v1.3.2
      with:
        subject-path: 'target/*.jar'
        subject-name: ${{ inputs.container-name }}-attestation

2. with Docker builds

Similarly, you can ensure that your Docker artifacts are properly attested, thereby enhancing the security and integrity of your build process. This approach helps in maintaining a robust supply chain security by providing verifiable evidence of how and where your Docker images were created.

    - name: Docker build-push
      id: docker-build
      uses: docker/build-push-action@v6
      with:
        context: .
        push: true
        tags: |
          ${{ inputs.acr-url }}/${{ inputs.container-name }}:latest
        # cache-from: type=registry,ref=${{ inputs.acr-url }}/${{ env.containerName }}:buildcache
        # cache-to: type=registry,ref=${{ inputs.acr-url }}/${{ env.containerName }}:buildcache,mode=max
        cache-from: type=gha
        cache-to: type=gha,mode=max   

    - name: Attest Docker build
      uses: actions/attest-build-provenance@v1.3.2
      id: attest
      with:
        subject-name: ${{ inputs.acr-url }}/${{ inputs.container-name }}
        subject-digest: ${{ steps.docker-build.outputs.digest }}
        push-to-registry: true

And by just Generating these attestations doesn’t boost security.

3. You need to verify them for it to actually make a difference. Here is an example how this can be verified

    - name: Verify OCI image
      shell: bash
      env:
        GH_TOKEN: ${{ inputs.github-token }}
      run: |
        gh attestation verify oci://${{ inputs.acr-url }}/${{ inputs.container-name }}:latest --owner "$GITHUB_REPOSITORY_OWNER"

You will see a detailed summary after the workflow execution is complete. it will show the status of the Docker build and push actions, indicating whether the image was successfully built and pushed to the specified container registry.

Additionally, it will include information about the attestation process, confirming whether the build provenance was properly attested and pushed to the registry.

Finally, the summary will display the results of the verification step, showing whether the OCI image was successfully verified using the provided GitHub token. This comprehensive summary helps ensure that each step of the workflow was executed correctly and provides valuable insights into the overall process.

By clicking on the Attestation URL, you will see detailed information.

Cache Maven

Maven usually takes a longer time to build the dependencies because it needs to download all the required libraries and plugins from remote repositories. This process can be significantly sped up by caching the Maven repository. To achieve this, you can set the path to the local Maven repository and use the key and restore-keys arguments in your caching configuration. By doing so, the dependencies are stored locally after the first run and can be reused in subsequent runs, eliminating the need to download them again. This approach not only saves time but also reduces the load on remote repositories, making your build process more efficient and reliable.

- name: Cache Maven
  uses: actions/cache@v4
  with:
    path: ~/.m2/repository
    key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
    restore-keys: |
      ${{ runner.os }}-m2-

Cache NodeJS

In Unix-based Operating Systems, NodeJS npm cache files are stored under ~/.npm. This directory contains all the cached files that npm uses to speed up subsequent installations of packages. By caching these files, you can significantly reduce the time it takes to install dependencies in future runs, as npm will reuse the cached files instead of downloading them again. This is particularly useful in continuous integration and deployment pipelines, where the same dependencies are often installed repeatedly. To cache the npm files, you can use the following configuration in your workflow:

- uses: actions/cache@v4
  with:
    path: ~/.npm
    key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
    restore-keys: |
      ${{ runner.os }}-node-
      ${{ runner.os }}-

Alternatively, this can be used directly with the setup-node action.

- uses: actions/setup-node@v4
  with:
    node-version: '20.x'
    cache: 'npm'
    cache-dependency-path: '**/package-lock.json'

Cache Python

Python dependencies can be cached to speed up workflow runs significantly. For pipenv, the dependencies are typically stored under ~/.local/share/virtualenvs. This directory contains the virtual environments created by pipenv, which include all the necessary packages and dependencies for your Python projects. By caching this directory, you can avoid the time-consuming process of reinstalling these dependencies during each workflow run.

for PIPENV

- uses: actions/cache@v4
  with:
    path: ~/.local/share/virtualenvs
    key: ${{ runner.os }}-python-${{ steps.setup-python.outputs.python-version }}-pipenv-${{ hashFiles('Pipfile.lock') }}

for PIP

- uses: actions/cache@v4
  with:
    path: ~/.cache/pip
    key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
    restore-keys: |
      ${{ runner.os }}-pip-

Cache Docker

Significantly speed up your Docker builds by leveraging GitHub's infrastructure to store and retrieve cache layers. Docker provides multiple caching options, including Registry Cache, Inline Cache, and GitHub Cache. Each method has its own advantages, but I recommend using GitHub Cache with the type=gha as it is integrated seamlessly with GitHub Actions, making it easier to set up and manage within your CI/CD workflows.

    - name: Build and push
      uses: docker/build-push-action@v6
      with:
        # context: docker-springboot
        context: .
        push: true
        tags: |
          ${{ inputs.acr}}/${{ github.event.repository.name }}:latest
        # cache-from: type=registry,ref=${{ inputs.acr-url }}/${{ env.containerName }}:buildcache
        # cache-to: type=registry,ref=${{ inputs.acr-url }}/${{ env.containerName }}:buildcache,mode=max
        cache-from: type=gha
        cache-to: type=gha,mode=max

Cache Go

Like other builds, Go builds can benefit significantly from caching. By storing and reusing dependencies and build artifacts, we can drastically reduce build times and improve efficiency. GitHub Actions provides a convenient way to cache Go modules and build outputs, ensuring that subsequent builds are faster and more reliable.

- uses: actions/cache@v4
  with:
    path: |
      ~/.cache/go-build
      ~/go/pkg/mod
    key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
    restore-keys: |
      ${{ runner.os }}-go-

Similarly, we can use the caching directly using setup-go action

  - uses: actions/setup-go@v5
    with:
      go-version: '1.17'
      check-latest: true
      cache-dependency-path: "**/*.sum"

You can find more information and detailed instructions on how to use the caching feature by visiting the Cache action page.

By following the above examples, you can ensure that your builds are not only faster but also more efficient and reliable. Whether you are working with Go, Node.js, Python, or any other language, the Cache action can help you to implement effective caching in your GitHub Actions workflows.

1. In the penny game exercise, why do you think it takes longer for one person to flip five batches of two pennies then one batch of ten pennies?

You have less collaboration on one large batch of work

2. How does the Pareto principle apply to product development?

Often 80% of your product's value comes from 20% of your efforts

3. Your team has been working on a software project for over a year. The software is behind schedule, so the executives have pressured the managers to try an agile approach. The manager for your team says that there are three project milestones coming up in the next six months. So the manager suggests that they simply rename the three milestones Sprint 1, Sprint 2 and Sprint 3. What's the biggest challenge with this approach?

It's unlikely that your team will get any benefit from an agile mindset by following existing practices

4. What does it mean when you say that Scrum separates the "what" from the "how?"

The product owner decides what the team will deliver, and the team decides how they'll deliver it

5. You work as a software developer on an agile team. Your manager has decided that the team must work off the existing requirements documents. What's one of the main challenges with this approach?

Agile teams embrace change, requirement documents are designed to limit conversation and flexibility

6. Your agile team only has one database developer. So the other developers finish their tasks and then wait for their work to be Integrated into the database. This creates a backup for the database developer. But it also means that the other developers must either wait or add to a growing pile of database work. What's one possible solution to this challenge?

Have the database developer train the rest of the team so there are fewer handoffs

7. What does it mean that Scrum defines itself as a "framework for empirical process control?"

It means that Scrum teams are encouraged to run experiments to improve the product

8. What is typically not part of the product owner's role?

They create the project requirements documentation

9. What's the best definition of a product iteration?

It is an incremental step towards delivering your product

10.The business analysts at your organization often take weeks to come up with an updated set of requirements. So the senior developer for your team encourages everyone to catch up on their training while they wait for the update. If you were an agile coach for the organization, what might you do to improve the situation?

You would encourage someone from the business to sit with the team to eliminate the handoff

11. In the Agile Manifesto Principles 3 and 7 recommend continuous software delivery in "weeks" as a measure of progress. What's one of the ways an agile team can follow this principle?

Deliver software in two-weeks iterations or "Sprints"

12. Your agile team has a senior developer that's been with the organization for over a decade. Whenever something goes wrong with the product, the director pulls this person out of the team to fix the trouble. What's likely to happen on your agile team when this person is pulled from their tasks?

Agile teams work in close collaboration, so this will likely create a backup

13. The director of your software product development team has started a new initiative that emphasizes organizational knowledge sharing. So they purchased licenses for a social group chat platform. They asked you to keep the platform open to answer questions that are relevant to the product. Why might this be difficult for your agile team?

The platform will encourage your team to multitask

14. How are organizational silos related to the penny game?

Organizational silos encouraged individuals to create large batches of work

15. When working with an agile team, managers will often give up long term plans for predictability. So why are agile teams more predictable?

Agile teams commit to delivering product increments every two weeks

16. Your agile team has set up a task board with a list of user stories under the "To Do" column. the Scrum Master says that the team can pull out the cards in any order that they like. So the developers start working on user stories that they think will be completed quickly. Is the Scrum Master right?

No, the agile team should always work on the highest priority user stories first

17. What is not a characteristic of a self-organized team?

These teams have a director who assigns everyone their tasks

18. What's one of the best ways to avoid the challenges with the cone of uncertainty?

Don't make all your decisions at the beginning when you know the least about the final product

Wanna thank me? 👇🏼

def verbing(s):
    returns iflen(s) < 3 elses + ('ing', 'ly')['ing' ins]
>>> verbing('help')
helping
>>> verbing('helping')
helpingly

2. use a bare “*” asterisk in function parameter lists to force the caller to use keyword arguments for certain parameters

>>> def f(a, b, *, c='x', d='y', e='z'):
...     return 'Hello'

To pass the value for c, d, and e you will need to explicitly pass it as “key=value” named arguments:

>>> f(1, 2, 'p', 'q', 'v')
TypeError: f() takes 2 positional arguments but 5 were given
>>> f(1, 2, c='p', d='q',e='v')
'Hello'

3. getpass module provides a platform-independent way to enter a password in a command-line program without echoing

>>> import getpass
>>> password = getpass.getpass()
Password:
>>> password
'alohomora'

getuser() gets the current username:

>>> getpass.getuser()
'sirius_black'

4. if the fractional component of the number is halfway between two integers, one of which is even and the other odd, then round() returns the even. This kind of rounding is called rounding to even (or banker’s rounding)

>>> round(0.5)
0
>>> round(2.4)
2
>>> round(2.5)
2
>>> round(2.6)
3
>>> round(3.5)
4
>>> round(4.5)
4

5. The built-in function sys.getsizeof() returns the size of an object in bytes. The object can be any type of object

>>> sys.getsizeof(1)
28
>>> sys.getsizeof([1, 2, 3])
88
>>> sys.getsizeof('')
49
>>> sys.getsizeof('P')
50
>>> sys.getsizeof('Py')
51
>>> sys.getsizeof('Python')
55

Definition:

Memory leak is a common memory issue that can result in an OutOfMemory error.
In Java, memory leaks can occur even with automatic Garbage Collection (GC).
GC removes objects that are no longer referenced.

However, if an object is not used but still referenced, GC will not remove it, potentially causing memory leaks in the JVM.

Conclusion:

Understanding memory leaks in the Java JVM is crucial for maintaining optimal application performance. Despite Java's automatic Garbage Collection, memory leaks can still occur when objects that are no longer needed remain referenced. This can lead to an OutOfMemory error, causing the application to crash or behave unpredictably. By identifying and addressing these leaks, developers can ensure more efficient memory usage and improve the stability and reliability of their Java applications.