11  Git and GitHub

Keywords

Version Control, Git, Cloud Collaboration, GitHub, Git Branches, Fork, Clone, Pull Request

11.1 Introduction

This chapter provides a basic introduction to Git and GitHub to support moving a cloud repository to GitHub and understanding the GitHub collaboration workflow Pull Request workflow.

Learning Outcomes

• Explain the difference between Git and GitHub
• Create a GitHub account
• Create a GitHub Personal Access Token (PAT)
• Authenticate between Posit Cloud and GitHub
• Use Version Control in Posit Cloud to create and update a GitHub repo
• Explain the differences between Fork and Clone for sharing repositories on GitHub
• Explain the purpose and flow of a GitHub Pull Request

11.1.1 References

• Git Home Page
• Managing your personal access tokens
• Git Credential Manager
• Getting started with your GitHub account

Other References

• Git for Scientists.
• Git Cheat Sheet
• Pro Git has more details on Git
• Using Version Control with RStudio
• Happy Git and GitHub for the RUser
• Git for Data Science

11.2 Why Use a Version Control System (VCS)

A Version control system is a program which tracks changes to your files over time in a way that allows you to see the entire change history and recall previous versions.

• VCS tools have been around for years to support software development projects.
• Popular ones include Git, Azure DevOps, and Subversion.
• Git is the most popular VCS at 86.6% market share.

Git allows you (and others) to go back to previous versions of your code/text and compare with the most recent version, or keep the old version and start a new development path.

• You can create copies of your code or files, change them, then merge these copies together later.

GitHub is a popular site for creating, collaborating on, and sharing Git-based repositories.

• You will see many R packages that are not ready for CRAN, or don’t want to be on CRAN, hosted and accessible on GitHub.

In short, version control is a best practice for any data science project as it provides transparency and reproducibility and enables collaboration across teams.

• Employers expect it.
• Your future you will appreciate it.
• Git, GitHub, and IDEs make it easy to integrate into your workflows.

11.3 Git Overview

Git works by managing file status using three levels as seen in Figure 11.1 :

Figure 11.1: The three levels of Git Workflow (Mark Lodato, n.d.)

Files start at the lowest level, the working directory. Users advanced files into the history or out of the history.

• Working Directory: Git uses the terminal working directory as its working directory.

  • This is the folder where your terminal pane shell tries to execute commands and where it looks for files.
  • It is not necessarily the same as your RStudio Console working directory!
  • Any changes to files you have saved but not staged or committed to Git only exist in the working directory and are not yet indexed or saved in the Git history.

• Stage: Files that are staged (added) are prepared (scheduled) to be committed to the history, but are not yet committed. Only files in the stage will be committed to the history.

• History: The timeline of file versions (snapshots). You commit a file to the history and then, even if you modify it later, you can always go back to that same file version.

• We’ll focus on the right-hand-side of Figure 11.1.

11.3.1 The Git Workflow for Version Control of Local Files.

A typical workflow for local version control has three steps:

1. Edit files as normal until you want to take a snapshot of one or more files. Save the files.
2. Stage/Add these modified files to the staging area.
3. Commit staged files to history, where they will be kept forever (on your computer).

The workflow on the left-hand side of Figure 11.1 is used to undo actions from the right side.

• Usually only when you need to undo mistakes or have changed your mind.

Important

Git does not save complete versions of the file each time.

• It tracks the differences that occur in each line of a text file and it can recreate the version at any point in the file’s commit history.
• The tracking of “differences” in text-based files allows for very efficient storage and processing.
• Git is not as efficient at tracking non-text (binary) files such as PDF or .xlsx where changes can only be identified at the whole file level.

Tip

Git uses a file called ,gitignore to avoid tracking folders and files you don’t want to commit.

• As an example, if you can generate an output file such as HTML, you do not need to commit it as you can always generate it when you need it.
• On A Mac you do not want to commit the DS_store file that Macs use for indexing directories.
• You can add these to your.gitignore` file so they do not clutter up your git actions.

Use the standard file/directory syntax to identify why you do not want to commit.

A typical .gitignore file might look the following

.Rproj.user
.Rhistory
.RData
.Ruserdata

/.quarto/
/_freeze
*_cache/
*_files/
*.html
/_book/
*output/

.DS_Store

11.3.2 Common Git Commands

Git is designed to work using the terminal and most IDEs have adopted a graphical interface.

• The terminal window provides access to all Git commands that may not be present in an integrated application.
• As an example, if you need to fix an error, like committing a very large (>100MB file) that will be rejected by GitHub for being too large, you must use commands only available in the terminal window.

All Git commands begin with git followed immediately by space and then an argument for the type of command you want to execute.

The following Git commands are used most often:

• git init: Initialize (or create) a Git repository. Only do this once per project/repository.
• git status: Show which files are staged in your working directory, and which are modified but not staged.
• git add: Add modified files from your working directory to the stage.
• git commit -m "descriptive message": commit your staged content as a new commit snapshot.
• git push: create a copy or update a copy of your repository on GitHub,

If you want to see the “differences” between the previous version and the current saved version, you can use

• git diff: Look at how files in the working directory have been modified.
• git diff --staged: Look at how files in the stage have been modified.

11.3.3 Repositories and Folder Structure (Housekeeping)

A repository (or repo, for short) is a collection of files (in a folder and its sub-folders) being version controlled (configuration managed) as a set.

• The repo also contains the local version control data, in a hidden .git folder and files.
  • You can use the RStudio IDE to see hidden files and folders by using the More option in the Files pane.

In data science, each repository is typically one project (like an analysis, a model, a homework, or a collection of code that performs a similar task).

• Users often turn a Git repo into an RStudio project as well. While Git does not care about whether a repo is an RStudio project, the RStudio IDE has features which make it easier to use Git with RStudio projects as we will see.

It is not a good practice to nest repos or RStudio projects inside each another repo or project!

• Before you create a new repo, take care that the terminal working directory is not already under a Git repo. Run git status and it should fail. If you get a status you are already in a repo.

11.4 Using GitHub as a Remote Repository for Version Control

11.4.1 Intro to GitHub

GitHub is a website that hosts Git repositories and allows workflows for collaboration and continuous integration (among other things).

• Don’t confuse Git with GitHub.
  • Git is version control system on your local machine or cloud workspace.
  • GitHub is a decentralized cloud-based system for managing and sharing many, many repositories.
• GitHub recommends repositories remain small, ideally less than 1 GB, and less than 5 GB is strongly recommended.
  • Smaller repositories are faster and easier to work with and maintain.
  • Individual files in a repository are strictly limited to a 100 MB maximum size limit.

Once you have a GitHub account, you do three things to host a repository on GitHub:

1. Create a repo on GitHub.
2. Tell Git where GitHub is going to host your repo (the URL).
3. Tell Git to move (push) your committed files and commit history to the designated GitHub repo.

Let’s start with getting and Account

11.4.2 Setting up GitHub

The course Posit Cloud workspace is a temporary Git repository. GitHub is an enduring cloud-based site for storing, sharing and collaborating on Git repositories.

• If you may want to establish a GitHub account and personal access token so you can create and update a GitHub copy of your cloud repository under your own account, follow the next steps.

11.4.2.1 Create a GitHub Account:

Go to https://github.com/ and select Sign up.

• Choose a free plan.
• Use your university email address or a personal address you check regularly.
• Choose your GitHub username carefully — you may use it professionally.
  • Include your name or initials (e.g., jsmith or jane-smith)).
  • Avoid user names you would not want on your résumé.

11.4.2.2 Create a Personal Access Token (PAT)

Posit Cloud (and Git in general) cannot use your GitHub password to push code to GitHub.

• Instead, GitHub allows you to use a Personal Access Token, a long random string that it generates for you to authenticate interactions with GitHub.

1. Go to https://github.com/settings/tokens (or navigate via Settings → Developer settings → Personal access tokens → Tokens (classic)).
2. Click Generate new token → Generate new token (classic).
3. Complete the 2FA prompt if asked.
4. Fill in the form:
   • Note: Give it a meaningful name, e.g., posit-cloud-intro-ds.
   • Expiration: Choose 90 days (a reasonable balance for a course; you can regenerate it later).
   • Scopes: Check the repo scope (this grants full access to your repositories). That is all you need for this course.
5. Scroll to the bottom and click Generate token.
6. Copy the token immediately since GitHub will never show it again.
7. Do not close the window showing the PAT.

Warning

The token is displayed only once. If you navigate away before copying it, you must delete it and generate a new one.

11.4.2.3 Store the PAT on Your Local Computer

Store the PAT securely somewhere on your computer so you can copy and paste it when Posit Cloud asks for it.

• The best place to store the PAT is in your local computer’s credential system.

If you have a Windows system, you can use the Git Credential Manager (GCM) that may be installed on your computer.

• Open the Control Panel -> Credential Manager -> Windows Credentials
• Create a generic credential such as: GitHub PAT.
  • Username: GitHub username
  • Password: Paste in your GitHUB Personal Access Token
• Save it.

If you have a Mac OS:

• Open Applications -> Utilities -> Keychain Access (not Password)
• Create a generic credential such as: GitHub PAT
  • Name: git:https://github.com
  • Account: GitHub username
  • Where: git:https://github.com
  • Password: Paste in your GitHUB Personal Access Token
  • Comment: GitHub PAT for Posit Cloud and others
• Save it.

Now, whenever you need to enter your PAT, you can open the credential manager and copy it to then paste into the pop up window or cursor prompt.

Note

For local computer Git to GitHub interactions both Windows and Mac systems can use a version of Git Credential Manager to register the credential manager and credential with GitHub so it authenticates silently in the future.

• Posit Cloud does not have this feature. You could store your GitHub PAT in you Posit Cloud account but for this course we’ll just copy and paste it.

11.4.2.4 Set the GitHub Default Branch Name to “main” for New Repositories

• Go to your GitHub account Settings (click on your profile picture in the top right).
  • Select Repositories
  • Change the Repository default branch for new repos to use “main”.

11.4.3 Create a Repository on GitHub

• Go to your GitHub account with your GitHub ID
• Create a new repo on GitHub by selecting New on the homepage:

One option for creating a new repository. There are other ways as well.

• Tell GitHub the name of your repo.
  • For this class, name it “posit_workspace”.
• To avoid errors, do not initialize the new repository with README, license, or .gitignore files.
  • You can add these files after your project has been pushed to GitHub.
• Set the repo to Private (not like the image!)
• Then, click Create Repository.

• You will get a new screen with the suggestions for what to do on your computer in the terminal window to add code to your new repo

Figure 11.2

11.4.4 Tell Your Local Git Where GitHub Will Host Your Repository.

NoteIf We Had A New Repository

Normally we are working from a local computer with a new repository which is what Figure 11.2 expects.

We would follow the suggestion in Figure 11.2 to copy the Git Commands to tell Git to add a new remote repo (on GitHub) to store a copy of our local repo and tell Git the name and location of the new remote repository and paste them into our terminal.

• Use git remote add to tell Git the nickname for the remote repo and where it is hosted.
• This example uses the URL for my GHUser name and repo name. Substitute your own repo URL and name.

    git remote add origin https://github.com/rressler/life_exp_rressler.git

However we do not have a new repository as it has a link to an existing GitHub repo already!

• We will need to change that.

Open the terminal tab in RStudio in Posit Cloud and enter the command to ask if there is an existing Github (remote) repository.

git remote -v

You should get a response similar to the following:

origin  https://github.com/instructor/course-starter.git (fetch)
origin  https://github.com/instructor/course-starter.git (push)

The URL here is the location of a GitHub repository. We want to change that.

• It is generally of the form “https://github.com/GHUser/GitHubRepoName.git” where GHUser is the user name of the repo owner and “GitHubRepoName” is whatever the owner chose to name the repo on GitHub.

Use the command git remote to tell Git to do something associated with a remote repository, e.g., on GitHub.

Here we want to tell Git to set a new URL for the repo.

git remote set-url origin https://github.com/YOUR-USERNAME/YOUR-REPOSITORY.git

• In the above command, “origin” is just the nickname (or alias) we give to the location URL that is hosting our repo so we don’t have to type the URL every time.
  • We could have used “github” or “deep_space_nine” instead, but “origin” or “upstream” are traditional nicknames you will see in documentation and on-line posts. Think of the “o” in origin as “online”.

Now check with the command git-remote -v in the terminal to see if your name now appears in the response.

• If it does, you are ready to “push” your Workspace Files to GitHub.

11.4.5 Push Files From Your Local Repo to the Remote GitHub Origin

Before you push your files to GitHub you want to ensure they are all saved and in the commit history.

• Go to the Terminal and enter the following

git add -A
git commit -m "Save my course project"

• The -m stands for message and it is required and you have to put a message in quotes after it. This is used to help you (and others) identify the purpose or contents of the commit.

You should get a response about files being updated.

• You can check with

git status

The first time you are pushing to a brand new repo on GitHub, you need to use the -u flag (for upstream) and identify the remote nickname and branch:

git push -u origin main

• Read this as git push (first time) to the upstream online repo with the origin (URL) and merge to its main branch.

Important

• A window will pop up asking for your user name. Enter your GitHub user name.
• It will then ask for our password. Copy your PAT from the credential manager and paste that into the window. You will not see it there. Hit enter.

• You will see code scroll by in the terminal window showing the actions that are happening as part of the push.

When the push is complete, check your code is now up on GitHub.

• Once Git knows where to go on GitHub for a given repo, just use git push to push new commits to GitHub.

11.5 Git and GitHub in RStudio Projects

In addition to the Terminal, RStudio has a Git Pane for working with Git and GitHub for RStudio “Projects”.

• Users can convert a repository folder into an RStudio Project (see the upper right corner)
• Converting a folder into a project makes it easier to work with a project as it sets the working directories and exposes the Git Pane.

The Posit Workspace is already an RStudio Project as there is a project_name.Rproj file in the repo.

• We can see the Git Pane to the right of the Environment Pane Figure 11.3.

Figure 11.3: Posit Cloud RStudio Git Pane

The Git Pane mirrors what you would see or do using Git commands in the terminal.

• It shows the current status of modified and saved files (uncommitted changes) that are not listed your .gitignore file.
• It has several commands in its menu to allow you to execute common Git and GitHub commands.
• Diff and History open up a new window with either the un-committed changes to the selected file or the history of the committed changes to the selected file.
• You can stage (add), commit, and push or pull files to and from GitHub as seen in Figure 11.3.

11.6 Exercise 12: Using Git in RStudio

1. Open your notes file and make a small change to a line to edit a few words and save it.
   • Go to the Git pane and you should see your file with a blue M box meaning modified.
2. In the main Git Pane you can click the check box to the left of a file to stage it.
   • You will see the status change to staged.
3. Click on the Diff button to see a “git diff” of the file in a pop-up window instead of the terminal.

• The green lines are new lines (with a + in the terminal).
• The red lines are deleted lines (with a - in the terminal).
  • You can select a line, a chunk or a file to Stage.
  • You can use the separate buttons for each.

4. Click on the Commit button in the menu row.
   • A new window will open with files to be committed. (you can also stage or un-stage files by clicking on them here as well).
5. Write a commit message in the upper right Commit message box and click the Commit button below the message.

• You get a pop-up window with the results (from the terminal window).
• Notice the file has disappeared from the Git Pane file listing but shows up in the history.
• There is a Git status message in the Git pane that shows you are ahead of origin/main by one commit.

6. Select the Push button at the top right (green up arrow) to push to GitHub.

• The status message is now gone.

7. You can go to GitHub to see your updated files.

The combination of RStudio Projects with a dedicated pane for Git and GitHub makes for a convenient workflow for using Git and GitHub to manage your code.

11.7 Branching and Merging in Git and GitHub

Git uses the concept of a “branch” to allow you to work on your code without changing the already working code.

Users can create and synchronize multiple branches within a repository.

• The main branch is the top level branch which is usually reserved for working (or production) set of code.
• Developers create a new branch to work on new features or fix a bug in the working code.

Branching allows you to:

• Develop new features without disturbing a stable baseline.
• Test changes before integrating them into main.
• Work on multiple features in parallel.
• Reduce risk to deployed or production code.

11.7.1 A Branching Workflow: Summary

This is a deliberate summary of the basic workflow. In practice, there are additional steps, especially if other people are working on the code to minimize merge conflicts.

• Start at the main branch.
• Create a new branch with git branch my_branchname.
  • A branch is not a separate copy of the files.
  • A branch is a movable pointer to a specific commit in the repository’s history.
• When you are ready to work on your new code you git switch my_branchname
  • When you git switch to a branch, Git does its magic to quickly create the files for that specific branch based on the most recent commit in your environment (and on your hard drive).
  • That is what you see in the RStudio File Manager because they are the files on your drive.
• Work on your code, save the files and git commit -m as usual, only the commits are on the my_branchname branch of the git tree.
  • There are commands to create a copy of the branch on GitHub so you can push your code there so others can see it.
• When you are finished updating, testing and commuting your new code in the branch, you are ready to merge it back into the main branch.
  • Use git switch main to go back to the main branch.
  • Use git merge branchname to have git try to integrate the new code, line by line, with deletes and adds, into the main branch files.
• If there are no issues, it will finish the merge and create a new commit on main for you.
  • You can use git push to put the new code up on GitHub main branch.
• If there are issues, most commonly a “merge conflict”, that means you (or someone else) changed one or more lines of the code in main that were also changed in the new code.
  • Git will tell you and put markers in the file for you to identify the conflicts and edit the file to make it consistent.
  • Save it and all conflicts are resolved, it will complete the merge and you are ready to push.

Branching aligns naturally with “best-practice” Development–Test–Production workflows and team collaboration.

11.8 Collaboration on GitHub

11.8.1 GitHub Commands for Sharing Repositories

The key concept of GitHub is to enable widespread sharing of code while protecting the integrity of the code and the intellectual property rights of the code owners.

• Repo owners set read and write permissions for the public and for authorized users
• By default, you can create a copy of any of the public repositories and any private ones for which you have permission.

If you can see a repo, GitHub allows three main ways of creating a copy:

• fork copies a repo “horizontally”, from one GitHub account to another GitHub account without direct links or write permissions to the original repo.
• clone copies a repo “vertically”, moving a copy of a repo on a GitHub account down to your local machine while maintaining a link to the original (origin) on GitHub so it’s easy to update your copy or even write to the original repo (if authorized).
• download creates a file you can put on your local machine without any links.

When you have used fork or clone, you can sync across forks on GitHub or use git pull on your local computer to update your copy with any changes from the original repo.

GitHub supports two common team collaboration workflow models:

• Fork and Pull Model: when you have forked a repository from a team repo to your individual github account
• Shared Repository Model: when you have cloned the team repo to your local computer.

Choosing a workflow model enables consistent, parallel development while minimizing risk to the working baseline in main.

11.8.2 The Fork & Pull Workflow Model

In a Fork & Pull workflow model, each user creates a forked version of the repo on GitHub under their own organization and then clones the forked repo to their local machine.

• Users make all the changes they want locally (using branching of course).
• Users push their updates to their forked repo on GitHub.
• Users then initiate a “Pull Request” to ask the owners of the Original Repo to consider adding the update to a branch of the original repo., e.g., the Main or a test branch.
• This model is popular with open source projects because people can work independently, without upfront coordination, without putting the main code baseline at risk.
• As an example, anyone can fork the repos for tidyverse packages, make their own changes locally, and then submit pull requests for consideration by the tidyverse development team.

11.8.3 The Shared Repository Workflow Model

In a Shared Repository workflow model, each user creates a cloned of the repo on GitHub to their local machine.

• Users create branches for their work locally and on GitHub.
• Users push their updates to their branch of the repo on GitHub.
• Users then initiate a “Pull Request” to ask the owners of the Repo to consider adding the update to the main branch of the repo.
• This workflow model is slightly riskier as any contributor could push directly to main without using a pull request and create numerous merge conflicts for others if they are not communicating well.
• It is popular with small teams who are disciplined and experienced in Git and GitHub as it does not require going through a forked copy of the repo to sync all the changes.

11.9 The Pull Request Workflow

Both collaboration workflow models use Pull Requests to help sync and integrate changes to code.

The Pull Request workflow is built around branches on GitHub.

• It is tightly integrated with the underlying Git repository so anyone can see exactly what changes would be merged if they accept your request.

You can open a Pull Request at any point during the development process:

• When you have little or no code but want to share some screenshots or general ideas,
• When you’re stuck and need help or advice, or,
• When you’re ready for someone to review your work.

By using GitHub’s @mention system in your Pull Request message, you can ask for feedback from specific people.

• @GitHub_username anywhere in an issue or pull request notifies the person and subscribes them to future updates.
  
  • e.g., @rressler - what do you think?

Once a Pull Request has been opened, the persons reviewing your changes can enter questions or comments.

• You can reply as part of the “conversation” about the Pull Request
• As you get comments, you can continue to push updates resolving the comments to your GitHub branch.
• GitHub will show your new commits and any additional feedback you may receive in the unified Pull Request view.
• When done, someone with write privileges can either merge your code into a branch with the final changes or you can close the pull request.

11.9.1 Pull Request Life Cycle in Pictures

Pull Requests initiate discussion about proposed code changes with others on a team.

• Anyone with read access to a repository can create a pull request.

11.9.1.1 Create a Pull Request

If you pushed a branch, go to your branch on GitHub and click on the green button Compare & Pull Request as seen in Figure 11.4.

Figure 11.4: Start the Pull Request workflow if you pushed a branch ot GitHub.

• You can also click on Pull requests in the menu bar and then click on Compare & pull request or New pull request.
• Either way will bring up the Open a pull request page as in Figure 11.5.

Figure 11.5: Open a pull request page

• Check that the pull in the correct direction: main should be on the left and the branch is on the right with arrow going from the branch to main.
  • This page is for pulling from one branch to another within a repo.
  • You can also do a pull request to submit proposed changes to the original repo owners.
• GitHub automatically compares the two versions and provides its finding if they can be easily merged at the top.
• You can compare the two versions, especially if there are merge conflicts, using the diff pane at the bottom as in Figure 11.6.

Figure 11.6: Pull Request full page with diff pane at the bottom.

• Write comments for the reviewers.
• To select reviewers, click on the gear icon to see a drop down list of team members.
• Then click on Create pull request to distribute the request as in Figure 11.7.

Figure 11.7: Enter comments, select reviewers, and create the pull request.

11.9.1.2 Act on a Pull Request

If you are a reviewer of a pull request, select Pull requests in the repo menu bar to see the list of open pull requests.

You now have several options as in Figure 11.8.

• Review: You can review several aspects of the pull request by using the tab panels
  • Conversation shows you all the comments that have been made on a pull request
  • Commits allows you to delve into the list of commits since the last merge and then the details of individual commits,
  • Checks shows you the results of any GitHub actions that affect the pull request.
  • Files opens up a diff of the changes in the files.

Figure 11.8: Pull Request Choices: review, merege, comment, or close.

• When reviewing code you can comment on single or multiple lines by using the mouse to highlight them and clicking on the blue + sign that pops up on the left of the lines.
• That will open up the comment box where you can make suggestions and share with others.

Figure 11.9: Click on a line of code to comment on it.

• Merge Pull Request: Once you have reviewed the pull request and you want to merge, go to the middle of the page where GitHub provides the output of automated checks.
  • Github also shows that the branch has no merge conflicts with main.
  • When ready to merge, click on `Merge pull request.
    • There are three options, but just choose the default one for now. Other organizations may have guidance for which type of merge to use.
  • You will be asked to Confirm merge and enter comments so everyone can see them in the history.
  • Enter comments and click to confirm the merge.
  • The page will update as in Figure 11.10.
    • Note that GitHub also provides the option to automatically delete the branch that generated the pull request from the repo.
    • If you click on it, it will delete the branch and make a commit on the GitHub repo.

  

  Figure 11.10: GitHub after Merge is confirmed.

• Comment on or Close the Pull Request: If you decide not to merge, at the bottom of Figure 11.8 you can enter comments and share as to why, or you can enter comments and close the pull request without merging any code.
  • The Pull request will no longer show up in the open list.

Important

After a Pull Request updates the baseline, team members must use git pull to merge the changes into their local main branch so they are up to date. This would be part of an expanded branching workflow.

11.10 Summary

Version Control and Cloud Collaboration are baseline skills for data scientists (and software developers).

• Git and GitHub are very popular tools for these tasks but there are other options.
• Git allows you to track all changes to your text and data files in a transparent and repeatable manner. It is fast and efficient.
• GitHub allows you to work as part of a group or team on the same code base with tools to minimize conflicts across the code.

AI agentic systems use these same basic ideas when they are developing their own code or working on your code.

• They expect you to be familiar with the concept of saving and staging files, reviewing diffs of code, and executing merge commands.
• They also expect you to be making pull requests so you or others can review the code.
• Given sufficient permissions, AI Agents can send you Pull Requests to review their code before merging it into your baseline.

When working with an AI Agent on code, you are never a solitary developer, you are part of a “team” with the AI agent. Being familiar with version control and collaboration workflows will help you be more effective and efficient in working with the agent.

2-Minute Neuroscience: The Neuron. 2014. https://www.youtube.com/watch?v=6qS83wD29PY.

A Grammar of Animated Graphics. n.d. Accessed May 22, 2026. https://gganimate.com/.

“albertocairo.” n.d. In albertocairo. Accessed May 22, 2026. https://www.albertocairo.com.

Alex Notov. 2025. Introduction to Claude Skills. https://platform.claude.com/cookbook/skills-notebooks-01-skills-introduction#discovering.

Anthropic. 2024. Building Effective AI Agents. https://www.anthropic.com/engineering/building-effective-agents.

Anthropic. 2025. Claude. https://claude.ai.

Anthropic. n.d.-a. “Best Practices for Claude Code.” In Claude Code Docs. Accessed April 13, 2026. https://code.claude.com/docs/en/best-practices.

Anthropic. n.d.-b. “Claude Code Overview.” In Claude Code Docs. Accessed April 16, 2026. https://code.claude.com/docs/en/overview.

Anthropic Engineering. 2025. Effective Context Engineering for AI Agents. https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents.

Anthropic Engineering. n.d.-a. “Complete Context Engineering Guide.” In Claude. Accessed April 6, 2026. https://claude.ai/public/artifacts/f498a4cc-4c45-481c-a6dd-8e1d196dadb0.

Anthropic Engineering. n.d.-b. “Prompt Engineering Overview.” In Claude API Docs. Accessed April 10, 2026. https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/overview.

Anthropic Engineering. n.d.-c. “Prompting Best Practices.” In Claude API Docs. Accessed April 6, 2026. https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practices.

API Basic Call Structures – World Bank Data Help Desk. n.d. Accessed June 1, 2026. https://datahelpdesk.worldbank.org/knowledgebase/articles/898581.

ASA, American Statistical Association. 1983. Auto Data Set from the 1983 Exposition of Statistical Graphics Technology. https://lib.stat.cmu.edu/data-expo/1983.html.

AWS. n.d. “What Is RAG? - Retrieval-Augmented Generation AI Explained - AWS.” In Amazon Web Services, Inc. Accessed June 5, 2026. https://aws.amazon.com/what-is/retrieval-augmented-generation/.

Barret, Tyson, Matt Dowle, Arun Srinivasan, et al. 2025. Data.table: Extension of ‘Data.frame‘. https://r-datatable.com.

Bartley, Kevin. 2024. “Data Statistics (2025) - How Much Data Is There in the World?” In Rivery. https://rivery.io/blog/big-data-statistics-how-much-data-is-there-in-the-world/.

Brown, Tom B., Benjamin Mann, Nick Ryder, et al. 2020. Language Models Are Few-Shot Learners. arXiv:2005.14165. arXiv. https://doi.org/10.48550/arXiv.2005.14165.

Chang, Winston. n.d. R Graphics Cookbook, 2nd Edition. Accessed May 22, 2026. https://r-graphics.org/.

Chat with Large Language Models. n.d. Accessed August 15, 2025. https://ellmer.tidyverse.org/index.html.

“Claude Code Create Custom Subagents.” n.d. In Claude Code Docs. Accessed April 19, 2026. https://code.claude.com/docs/en/sub-agents.

“Claude Code Define Your Agent.” n.d. In Claude API Docs. Accessed April 19, 2026. https://platform.claude.com/docs/en/managed-agents/agent-setup.

Codex AI Assistant for Work and Code. n.d. Accessed June 8, 2026. https://chatgpt.com/codex/.

Csardi, Garbor. 2022. Keyring: Access the System Credential Store from R. https://r-lib.github.io/keyring/index.html.

DAIR-AI. 2025. Prompt Engineering Guide. https://www.promptingguide.ai/.

Davenport, Thomas H., and D J. Patil. 2012. “Data Scientist: The Sexiest Job of the 21st Century.” Harvard Business Review October 2012: 70–76. http://hbr.org/2012/10/data-scientist-the-sexiest-job-of-the-21st-century/ar/1.

Eurostat. n.d. Data Access via API - User Guides. Accessed June 1, 2026. https://ec.europa.eu/eurostat/web/user-guides/data-browser/api-data-access.

Firke, Sam. 2024. Janitor: Simple Tools for Examining and Cleaning Dirty Data. https://sfirke.github.io/janitor/.

Fox, John, and Sanford Weisberg. 2019. An Companion to Applied Regression. Third. Sage. https://www.john-fox.ca/Companion/.

Friedman, Jerome, Trevor Hastie, and Robert Tibshirani. 2010. “Regularization Paths for Generalized Linear Models via Coordinate Descent.” Journal of Statistical Software 33 (1): 1–22. https://doi.org/10.18637/jss.v033.i01.

Gábor Csárdi. 2023. Gitcreds: Query ’Git’ Credentials from ’R’. https://gitcreds.r-lib.org/.

Ggrepel: An R Package. n.d. Accessed May 22, 2026. https://ggrepel.slowkow.com/.

Godsey, Brian. 2017. Think Like a Data Scientist. Manning.

Google. n.d. Agent Development Kit (ADK). Accessed April 19, 2026. https://adk.dev.

Grolemund, Garrett, and Hadley Wickham. 2011. “Lubridate: Dates and Times Made Easy with Lubridate.” Journal of Statistical Software 40 (3): 1–25. https://www.jstatsoft.org/v40/i03/.

Grolemund, Garrett, and Hadley Wickham. n.d. R for Data Science. https://r4ds.had.co.nz/.

Groq. n.d. API Reference - GroqDocs. Accessed June 4, 2026. https://console.groq.com/docs/api-reference#chat-create.

Hadley Wickham. 2016. Ggplot2: Elegant Graphics for Data Analysis. Springer-Verlag New York. https://ggplot2.tidyverse.org/.

Hadley Wickham, Danielle Navarro, and Thomas Lin Pedersen. n.d. Ggplot2: Elegant Graphics for Data Analysis (3e). Accessed May 22, 2026. https://ggplot2-book.org/.

Horst, Allison, Alison Presmanes Hill, and Kristen B Gorman. 2020. Palmerpenguins R Data Package. https://doi.org/10.5281/zenodo.3960218.

Ian Fellows. 2022. Wordcloud: Word Clouds. Comprehensive R Archive Network. https://doi.org/10.32614/CRAN.package.wordcloud.

Institute of Statistics (INSTAT). 2025. Statistical Database. https://databaza.instat.gov.al:8083/pxweb/en/DST/.

Institute, QLB Brain. 2017. Stunning Neuroscience Images. https://qbi.uq.edu.au/blog/2017/07/stunning-neuroscience-images.

James, Gareth, Daniela Witten, Trevor Hastie, and Robert Tibshirani. 2023. An Introduction to Statistical Learning with Applications in R. 2nd ed. Springer. https://www.statlearning.com.

Janitor: Simple Tools for Examining and Cleaning Dirty Data — Janitor-Package. n.d. Accessed May 22, 2026. https://sfirke.github.io/janitor/reference/janitor-package.html.

Kalinowski, Tomasz et al. 2022. TensorFlow for R. https://tensorflow.rstudio.com/.

Kalinowski, Tomasz, JJ Allaire, and François Chollet. 2025. Keras3: R Interface to Keras. https://keras3.posit.co/.

Kanwal, Maxinder S., Avinash S. Ramesh, and Lauren A. Huang. 2013. A Novel Pseudoderivative-Based Mutation Operator for Real-Coded Adaptive Genetic Algorithms. 2:139. F1000Research. https://doi.org/10.12688/f1000research.2-139.v2.

Kaplan, Daniel, and Randall Pruim. 2023. Ggformula: Formula Interface to the Grammar of Graphics. https://www.mosaic-web.org/ggformula/.

Karatzoglou, Alexandros, Alex Smola, Kurt Hornik, National ICT Australia (NICTA), Michael A. Maniscalco, and Choon Hui Teo. 2024. Kernlab: Kernel-Based Machine Learning Lab. https://CRAN.R-project.org/package=kernlab.

Kelechava, Brad. 2018. “The SQL Standard - ISO/IEC 9075:2023 (ANSI X3.135).” In The ANSI Blog. https://blog.ansi.org/sql-standard-iso-iec-9075-2023-ansi-x3-135/.

Keras: Deep Learning for Humans. n.d. Accessed May 28, 2026. https://keras.io/.

Khun, Max, and Julia Silge. 2023. Tidy Modeling with R. https://www.tmwr.org/.

Kingma, Diederik P., and Jimmy Ba. 2017. Adam: A Method for Stochastic Optimization. arXiv:1412.6980. arXiv. https://doi.org/10.48550/arXiv.1412.6980.

Kuhn, Max, and Hadley Wickham. 2020. Tidymodels: A Collection of Packages for Modeling and Machine Learning Using Tidyverse Principles. https://www.tidymodels.org.

Lin, Hause, and Tawab Safi. 2025. “Ollamar: An R Package for Running Large Language Models.” Journal of Open Source Software, ahead of print. https://doi.org/10.21105/joss.07211.

Luo, Junyu. 2026. Luo-Junyu/Awesome-Agent-Papers. https://github.com/luo-junyu/Awesome-Agent-Papers.

Luo, Junyu, Weizhi Zhang, Ye Yuan, et al. 2025. Large Language Model Agent: A Survey on Methodology, Applications and Challenges. arXiv:2503.21460. arXiv. https://doi.org/10.48550/arXiv.2503.21460.

Mark Lodato. n.d. A Visual Git Reference. Accessed May 30, 2026. https://marklodato.github.io/visual-git-guide/index-en.html.

Mei, Lingrui, Jiayu Yao, Yuyao Ge, et al. 2025. “A Survey of Context Engineering for Large Language Models.” In arXiv.org. https://arxiv.org/abs/2507.13334v2.

Mosaic Plots in the Ggplot2 Framework. n.d. Accessed May 22, 2026. https://haleyjeppson.github.io/ggmosaic/.

Myer, David. 2024. E1071: Misc Functions of the Department of Statistics, Probability Theory Group. https://cran.r-project.org/web/packages/e1071.

Neal Richardson, Ian Cook, Nic Crane, et al. 2026. Arrow: Integration to ’Apache’ ’Arrow’. https://github.com/apache/arrow/.

Nohe, Patrick. 2017. What Is the Dark Web? https://www.thesslstore.com/blog/what-is-the-dark-web/.

Ollama. 2025. https://ollama.com.

Ooms, Jeroen. 2014. “Jsonlite: The Jsonlite Package: A Practical and Consistent Mapping Between JSON Data and R Objects.” arXiv:1403.2805 [Stat.CO]. https://arxiv.org/abs/1403.2805.

Ooms, Jeroen. 2023. Jasonlite Vignette: Getting Started with JSON and Jsonlite. https://cran.r-project.org/web/packages/jsonlite/vignettes/json-aaquickstart.html.

Open Data Inventory—Global Index of Open Data - Open Data Inventory. n.d. Accessed May 8, 2025. https://odin.opendatawatch.com/.

OpenAI. 2025. Prompt Engineering - OpenAI API. https://platform.openai.com/docs/guides/prompt-engineering.

OpenAI. 2026. A Practical Guide to Building Agents. https://openai.com/business/guides-and-resources/a-practical-guide-to-building-ai-agents/.

OpenAI Developers. n.d. Agents SDK. Accessed April 16, 2026. https://developers.openai.com/api/docs/guides/agents.

OWASP Foundation. n.d. Least Privilege Principle. Accessed April 19, 2026. https://owasp.org/www-community/controls/Least_Privilege_Principle.

Pebesma, Edzer. 2018. “Sf: Simple Features for R: Standardized Support for Spatial Vector Data.” The R Journal 10 (1): 439–46. https://r-spatial.github.io/sf/.

Plaat, Aske, Max van Duijn, Niki van Stein, Mike Preuss, Peter van der Putten, and Kees Joost Batenburg. 2025. “Agentic Large Language Models, a Survey.” In arXiv.org. https://doi.org/10.1613/jair.1.18675.

Plotly r Graphing Library in R. n.d. Accessed May 23, 2026. https://plotly.com/r/.

Posit. 2025a. Posit Cheatsheets. https://posit.co/resources/cheatsheets/.

Posit. 2025b. Positron. https://positron.posit.co/.

Posit. 2025c. “RStudio IDE User Guide.” In RStudio User Guide. https://docs.posit.co/ide/user/.

Posit. 2026. “Quarto Guide.” In Quarto. https://quarto.org/docs/guide/.

Positron. n.d.-a. “Guide for Positron Assistant.” In Positron. Accessed April 18, 2026. https://positron.posit.co/assistant.html.

Positron. n.d.-b. “Positron Assistant Getting Started.” In Positron. Accessed April 18, 2026. https://positron.posit.co/assistant-getting-started.html.

Quarto. 2025. Posit.co. https://quarto.org/.

Rashida048. 2020. Machine Learning: Gradient Descent Concept – Regenerative. https://regenerativetoday.com/machine-learning-gradient-descent-concept/.

Robinson, Julia Silge and David. n.d. Text Mining with R. Accessed April 12, 2020. https://www.tidytextmining.com/.

Ruman. 2023. “Convex Vs. Non-Convex Functions: Why It Matters in Optimization for Machine Learning.” In Medium. https://rumn.medium.com/convex-vs-non-convex-functions-why-it-matters-in-optimization-for-machine-learning-39cd9427dfcc.

Sahoo, Pranab, Ayush Kumar Singh, Sriparna Saha, Vinija Jain, Samrat Mondal, and Aman Chadha. 2024. “A Systematic Survey of Prompt Engineering in Large Language Models: Techniques and Applications.” In arXiv.org. https://arxiv.org/abs/2402.07927v2.

Silge, Julia, and David Robinson. 2023. Tidytext: Text Mining Using Tidy Tools. https://juliasilge.github.io/tidytext/.

Silge, Julia, and David Robinson. 2025. Tidytext: Text Mining with R. O’Reilly Media, Inc. https://www.tidytextmining.com/.

Simple Tools for Examining and Cleaning Dirty Data. n.d. Accessed May 22, 2026. https://sfirke.github.io/janitor/index.html.

Sjoberg, Daniel D., Karissa Whiting, Michael Curry, Jessica A. Lavery, and Joseph Lamarange. 2021. “Reproducible Summary Tables with the Gtsummary Package.” The R Journal 13 (1): 570–80. https://doi.org/10.32614/RJ-2021-053.

Stryker, Ivan Belcic, Cole. 2024. What Is Data Engineering? IBM. https://www.ibm.com/think/topics/data-engineering.

Takeda, Hajime. 2026. “How to Build a Production-Ready Claude Code Skill.” In Towards Data Science. https://towardsdatascience.com/how-to-build-a-production-ready-claude-code-skill/.

Team, R Core. 2018. R: A Language and Environment for Statistical Computing. R Foundation for Statistical Computing. https://www.R-project.org/.

“TensorFlow.” n.d. In TensorFlow. Accessed May 28, 2026. https://www.tensorflow.org/.

The Composer of Plots. n.d. Accessed May 22, 2026. https://patchwork.data-imaginist.com/.

“The Visual Display of Quantitative Information.” n.d. In Edward Tufte. Accessed May 22, 2026. https://www.edwardtufte.com/book/the-visual-display-of-quantitative-information/.

Ushey, Kevin, JJ Allaire, and Yuan Tang. 2023. Reticulate: R Interface to Python. https://rstudio.github.io/reticulate/.

van Rossum, Guido. 2025. Python. https://www.python.org/.

Vaswani, Ashish, Noam Shazeer, Niki Parmar, et al. 2023. Attention Is All You Need. arXiv:1706.03762. arXiv. https://doi.org/10.48550/arXiv.1706.03762.

VoltAgent/Awesome-Claude-Code-Subagents. 2026. VoltAgent. https://github.com/VoltAgent/awesome-claude-code-subagents.

Waring, Elin, Michael Quinn, Amelia McNamara, Eduardo Arino d la RUbia, Shu Hao, and Shannon Ellis. 2025. Skimr: Compact and Flexible Summaries of Data. https://docs.ropensci.org/skimr/.

Weng, Lilian. 2023. Prompt Engineering. https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/.

Wickham, Hadley. 2010. “A Layered Grammar of Graphics.” Journal of Computational and Graphical Statistics 19 (1): 3–28. https://doi.org/10.1198/jcgs.2009.07098.

Wickham, Hadley. 2016. Ggplot2: Elegant Graphics for Data Analysis. Springer-Verlag New York. https://ggplot2.tidyverse.org/.

Wickham, Hadley. 2023a. Forcats: Tools for Working with Categorical Variables (Factors). https://forcats.tidyverse.org/.

Wickham, Hadley. 2023b. Httr2: Perform HTTP Requests and Process the Responses. https://httr2.r-lib.org/.

Wickham, Hadley. 2023c. Modelr: Modelling Functions That Work with the Pipe. https://modelr.tidyverse.org/.

Wickham, Hadley. 2023d. Stringr: Simple, Consistent Wrappers for Common String Operations. https://stringr.tidyverse.org/.

Wickham, Hadley, Mara Averick, Jennifer Bryan, et al. 2019. “Welcome to the Tidyverse.” Journal of Open Source Software, no. 43: 1686. https://doi.org/10.21105/joss.01686.

Wickham, Hadley, and Jennifer Bryan. 2023. Readxl: Read Excel Files. https://readxl.tidyverse.org.

Wickham, Hadley, Mine Cetinkaya-Rundel, and Garrett Grolemund. 2023. R for Data Science (2e). O’Reilly Media, Inc. https://r4ds.hadley.nz/.

Wickham, Hadley, Romain Francois, Lionel Henry, Kirill Muller, and Davis Vaughan. 2023. Dplyr: A Grammar of Data Manipulation. https://dplyr.tidyverse.org.

Wickham, Hadley, Jim Hester, and Jennifer Bryan. 2024. Readr: Read Rectangular Text Data. https://readr.tidyverse.org/.

Wickham, Hadley, Davis Vaughan, and Maximilian Girlich. 2023. Tidyr: Tidy Messy Data. https://tidyr.tidyverse.org.

Wikipedia. 2025. “Data Science.” In Wikipedia. https://en.wikipedia.org/wiki/Data_science.

World Bank. n.d.-a. About the Indicators API Documentation. Accessed June 1, 2026. https://datahelpdesk.worldbank.org/knowledgebase/articles/889392-about-the-indicators-api-documentation.

World Bank. n.d.-b. Indicator API Queries. Accessed June 1, 2026. https://datahelpdesk.worldbank.org/knowledgebase/articles/898599-indicator-api-queries%3E.