1.1 Have these items ready🔗

• Your SHU username, password, email access, and multifactor-authentication device.

• Access to your personal Gmail account. If you need one, create it before starting Track A.

• A government-issued ID for Google’s age-verification step.

• Your SHU student ID and a current proof of enrollment. GitHub accepts a school ID only when it displays a current enrollment date. If yours does not, have a current class schedule, transcript, or official enrollment-verification letter available instead.

• Your Windows laptop and its charger.

Keep every setup free. Do not enter a credit card, enable billing, purchase credits, or start a paid subscription or trial. Use the free account and provider settings below. Provider terms and limits were checked on September 15–16, 2026; the linked official pages provide current details.

1.2 Track A: JetBrains account to educational IntelliJ license🔗

1. Create or sign in to a single JetBrains Account. Use your personal Gmail address when creating an account. Keep using this account at the later activation screen.

2. Apply for the free JetBrains Student Pack. Use your SHU academic email for student verification. See the Student Pack requirements.

3. Follow the confirmation link JetBrains sends. Start the remaining account tracks while JetBrains reviews your application.

4. After approval, open your JetBrains licenses. Confirm that an active student or educational license includes IntelliJ IDEA, and note its expiration date.

Use the educational IntelliJ license for the course. While approval is pending, submit the other verification requests and prepare the course folders and downloads. Contact course staff if you need help resolving a verification problem.

1.3 Track B: Personal Gmail, age verification, and Google AI Studio🔗

Use one personal Gmail account as your second email account alongside SHU.

1. Sign in to your personal Gmail account. Use this same account for the Google steps below.

2. Open Google’s age verification page while signed into that account. Complete the verification using a government-issued ID: select Verify > Use your ID, upload a clear image, confirm your birth date, and submit. Follow Google’s ID verification instructions. If Google already recognizes your age, continue to the next step.

3. Sign in to Google AI Studio with that same account and accept its terms.

4. Confirm that you can open its API keys page. We will create and connect the key in the IntelliJ section.

5. Keep the project on Free Tier with billing disabled.

Google’s Free Tier may use prompts and responses to improve Google products. Use it with public course materials and your own non-sensitive work.

1.4 Track C: One GitHub account, two email addresses, and Copilot Student🔗

Use one GitHub account with two verified email addresses. The account needs (1) your personal Gmail address and (2) your SHU academic email address for student-status verification. Keep both addresses on that one account.

1. Choose the one GitHub account you will use. If you already control a GitHub account, sign in to that account and do not create another one. This includes an account that currently uses only your SHU email. Create an account only if you do not already own a GitHub account.

2. Open GitHub email settings and make sure both your personal Gmail address and your SHU academic email are listed and verified on that same account. If the account currently has only the SHU email, add your Gmail address; if it has only your Gmail address, add your SHU email.

3. Enable two-factor authentication and save the recovery codes somewhere other than this laptop.

4. Open GitHub Education benefits, choose Start an application, and use the verified SHU email when requested.

5. If GitHub requests evidence, upload one clear image showing your name, Seton Hall University, and current enrollment. A student ID without a current date is insufficient by itself; use a current schedule, transcript, or enrollment-verification letter instead.

6. Continue the other account tracks while GitHub reviews the application. Return here when GitHub marks the account as a verified student.

7. Return to GitHub Education benefits. Under Free GitHub developer resources for students and teachers, choose Learn more and activate Copilot Student.

8. In GitHub Settings, open Billing & licensing > Licensing. Under Current plan, confirm that the Copilot license is Copilot Student.

GitHub Education approval and Copilot activation are separate. Activation can take several days. Do not start a paid trial or enter a payment method. See GitHub’s student-verification instructions, Copilot Student instructions, and plan-verification instructions.

1.5 Track D: ChatGPT and the Codex student-credit offer🔗

1. Create or sign in to your personal ChatGPT account. Use your personal Gmail address when creating an account. Choose Free; this account also gives you Codex access.

2. Open Codex for Students, choose Claim now, and complete the student verification using that ChatGPT account and your SHU email. Continue the other setup steps while the request is reviewed.

3. After approval, check the usage page for the grant: 2,500 credits ($100), expiring 12 months after the grant.

A personal Free account qualifies for the grant. The credits fund Codex use through your ChatGPT account. While verification is pending, use the included Free-plan Codex allowance, then return to confirm that the grant was applied.

1.6 Track E: Groq account🔗

Create or sign in to a Groq Console account. Use your personal Gmail address when creating an account and complete email verification. Stay on the Free Plan. We will create the API key when connecting IntelliJ.

1.7 Track F: Inception account for Mercury🔗

Create or sign in to an Inception Platform account using your personal Gmail address. New accounts receive 100 million free tokens with no payment details required. We will create the API key when connecting IntelliJ. See Inception’s account setup instructions.

1.8 Track G: Kilo account🔗

Create or sign in to a Kilo account using your personal Gmail address. Its free hosted coding models require no credit card. We will select the free models in the IntelliJ plugin below.

1.9 SHU course services🔗

1. Open Microsoft 365 Copilot Chat, sign in with your SHU work-or-school account, and bookmark the page. Confirm that the page shows the SHU account.

2.1 Create the course folders🔗

In File Explorer, create the following folders. Replace YOURUSERNAME with your Windows account name.

Keep course projects out of temporary download folders. If Windows redirects your Documents folder into OneDrive, the location above also avoids accidental cloud-sync conflicts in IntelliJ projects.

2.2 Install IntelliJ IDEA through JetBrains Toolbox🔗

1. Download and install the JetBrains Toolbox App for Windows.

2. Sign in to Toolbox with the same JetBrains Account that owns your educational license.

3. Install the current stable release of IntelliJ IDEA (2026.2 at this check). Use 2026.1 or newer for the Codex integration and current AI Assistant provider settings. Do not install an Early Access Program build. Keep the IDE and plugins updated; Marketplace must show each plugin as compatible with your installed version.

4. Open IntelliJ and select Help > Manage Subscriptions (or Help > Register). Confirm that IntelliJ is activated by the educational license. If the dialog says Trial, stop and sign out; then sign back in with the JetBrains Account that owns your educational license.

2.3 Select JDK 11🔗

IntelliJ includes enough Java to run the IDE, but the course requires a separate Java Development Kit, version 11, to compile programs. JDK 11 is the requirement; the vendor, installation folder, and name that IntelliJ displays for it are not. In particular, an SDK name such as homebrew-11 describes one installation on one computer. Do not install Homebrew or reproduce another computer’s SDK name.

When you create the course project template below, select an existing JDK 11 if IntelliJ finds one. Otherwise choose Download JDK, select Version 11, and use any available OpenJDK vendor. IntelliJ will offer a download appropriate for macOS, Windows, or Linux. Keep the default installation location. If JDK 11 is already installed but IntelliJ does not find it, choose Add SDK from Disk and select its home directory. See JetBrains’s project JDK instructions for the same three choices.

2.4 Download the course libraries🔗

Download tester.jar and javalib.jar from the links at the top of this page. Save both files directly in C:\Users\YOURUSERNAME\CSAS2123\libraries. Do not open, extract, or rename the JAR files.

2.5 Configure IntelliJ yourself🔗

Follow the course Code style instructions now. In particular, verify two-space indentation with spaces rather than tab characters, a 100-character wrap guide, visible line numbers, and the course inspections concerning this. These are user settings: each student must configure and verify them on their own computer.

2.6 Create the course project template🔗

1. Open IntelliJ and choose New Project. Select Java, use the IntelliJ build system, name the project CSAS2123-template, and place it inside C:\Users\YOURUSERNAME\CSAS2123\projects. Do not create a Git repository yet.

2. In the JDK menu, select an installed JDK 11. If none is listed, choose Download JDK, select Version 11, and use any available vendor.

3. Open File > Project Structure > Project. Confirm that the SDK is the JDK 11 selected above and set Language level to 11 - Local variable syntax for lambda parameters.

4. Under Project Structure > Libraries, add tester.jar and javalib.jar from your course libraries folder as Java libraries. Apply the changes.

If AI approvals are still pending, run the supplied environment check now to confirm that IntelliJ is ready for coursework. Return to the AI setup below as those approvals arrive.

3.1 Install the plugins once🔗

1. With the course project open, use File > Settings > Plugins > Marketplace (on macOS, IntelliJ IDEA > Settings).

2. Install GitHub Copilot by GitHub, AI Assistant by JetBrains, and Kilo Code. Use the latest compatible versions and restart when prompted.

3. Open AI Chat. Choose Pick an agent or Use your API key if offered; close subscription offers and configure the provider connections below.

Use stable IntelliJ 2026.2; 2026.1 or newer is needed for Codex and the current Kilo plugin. If Marketplace reports incompatibility, update through Toolbox and check plugin updates. See the official Copilot and AI Assistant installation guides, Kilo’s JetBrains plugin guide, and JetBrains’s 2026.1 agent support announcement.

Use ChatGPT authorization for Codex and your own Google/Groq/Inception provider entries for the API connections. These settings charge usage to the free allowances you set up above. See activation options.

3.2 GitHub Copilot Student🔗

1. Select Tools > GitHub Copilot > Login to GitHub, then Copy and Open.

2. In the browser, use the GitHub account from Track C, enter the displayed device code, and authorize the plugin. Return to IntelliJ and confirm that the Copilot status icon says it is ready.

3. Open Copilot Chat, keep Auto model selection, and send Explain what an IDE does in one sentence. Confirm a response.

Allowance and use elsewhere: Student includes unlimited code completions and a monthly AI-credit allowance for chat and agents. Free has 2,000 completions/month and a smaller AI-credit allowance. Check Copilot usage for your current credit amount; credits reset on the first of the month (UTC). Current GitHub billing measures chat and agent usage in AI credits. Supported Copilot tools include other editors, GitHub.com, and Copilot CLI. These share the account allowance through your GitHub sign-in.

If IntelliJ used the wrong account, sign out of Copilot and repeat the login. If it shows Free while Education approval is pending, keep working and activate Student on the same account after approval.

3.3 Codex through JetBrains AI Assistant🔗

JetBrains AI Assistant provides the IntelliJ integration for Codex. See OpenAI’s Codex IDE instructions and JetBrains’s agent-activation instructions.

1. In IntelliJ, open AI Chat and choose Codex in the agent selector.

2. Send Reply with exactly: Codex is connected. to trigger activation. Choose Install and Continue when IntelliJ asks to install the agent and accept the applicable terms.

3. At the authentication prompt, choose ChatGPT. Complete the OpenAI sign-in in the browser with the account from Track D and authorize Codex.

4. Return to IntelliJ. Open File > Settings > Tools > AI Assistant > Providers & API keys. Under Agent Authorization, confirm that Codex uses ChatGPT.

5. Return to the new Codex chat and confirm that its response is exactly Codex is connected.

Allowance and use elsewhere: Free includes limited Codex use; the student grant adds the finite credit balance claimed above. Model, task size, and context affect how much each task uses. Check the usage dashboard for remaining allowance, credits, and reset times. The same account works in Codex CLI and supported Codex desktop/web tools, subject to plan availability. IDE, CLI, and cloud use share the account allowance; ChatGPT Work also shares Codex usage. See current limits and plans. When you reach a usage limit, switch providers.

Start Codex in Read-only mode. When you intentionally want file edits, use Agent, review the diff, and run the tests yourself. Codex can receive project files, the active file, and selected text. Keep passwords, API keys, and other secrets outside your course project.

3.4 Gemini free API through JetBrains AI Assistant🔗

1. Open Google AI Studio API keys with the account from Track B. Use its default project or create one in AI Studio, and confirm Free Tier; leave billing disabled.

2. Create a new key using AI Studio’s current flow and copy it directly to IntelliJ. Google’s key notice says old standard keys will be rejected starting September 2026; new keys use the required authorization-key format. Replace an older standard key rather than reusing it.

3. In IntelliJ, open File > Settings > Tools > AI Assistant > Providers & API keys. Add Google as a third-party provider, paste the Gemini API key, and choose Test Connection. Apply after the test succeeds. Choose the Google / Gemini API connection.

4. In ordinary AI Chat, select gemini-2.5-flash under your configured Google provider. Send Reply with exactly: Gemini is connected. Verify the response, then clear the API key from the Windows clipboard by copying some ordinary text.

Model and allowance: At this check, gemini-2.5-flash has free input/output. Consult Google’s free-tier pricing and deprecation notices before choosing a replacement, and select a model with a current free tier. If the model is missing, update the IDE and AI Assistant plugin, then check the model selector again.

AI Studio’s active limits show your model’s request and token limits. These vary by model and account; all keys for a project share its quota, and daily requests reset at midnight Pacific. See Google’s rate-limit guide.

Use elsewhere: This portable API key works in compatible apps, scripts, and Gemini CLI in API-key mode; all use the same project’s API quota. Any browser tool using that project’s key shares it too. AI Studio also offers browser experimentation; check its displayed limits for browser use. The consumer Gemini app and Gemini CLI’s Google sign-in option have different access rules and allowances.

3.5 Groq free API through JetBrains AI Assistant🔗

1. In Groq Console API Keys, create a key for your Free account and copy it directly to IntelliJ.

2. Under Settings > Tools > AI Assistant > Providers & API keys > Third-party AI providers, select OpenAI-compatible. Enter the endpoint https://api.groq.com/openai/v1 and your Groq key. This connects to your Groq account.

3. Click Test Connection, then Apply. In ordinary AI Chat, select openai/gpt-oss-20b under that provider and send Reply with exactly: Groq is connected. Confirm the response, then clear the clipboard by copying ordinary text.

See Groq’s compatible endpoint and JetBrains’s provider settings. If needed, select the model under Models Assignment for Core features.

Allowance and use elsewhere: The current Free limits for openai/gpt-oss-20b are 30 requests/minute, 1,000 requests/day, 8,000 tokens/minute, and 200,000 tokens/day. Any one limit can stop a request; keep the connection check short. Check your account limits and the Free Plan Limits table for changes. This portable key works in compatible apps, scripts, and CLI clients; Groq also has a browser Playground. Usage within the same Groq organization shares quota across clients and keys.

3.6 Mercury through JetBrains AI Assistant🔗

1. Open Inception Platform with the account from Track F. Under API Keys, create a key and copy it directly to IntelliJ.

2. Under Settings > Tools > AI Assistant > Providers & API keys > Third-party AI providers, select OpenAI-compatible. Enter https://api.inceptionlabs.ai/v1 and your Inception key. Enable Tool calling, then click Test Connection and Apply.

3. Under Model Assignment, select mercury-2.5 for Core features and Instant helpers. In ordinary AI Chat, select that model and send Reply with exactly: Mercury is connected. Confirm the response, then clear the clipboard by copying ordinary text.

See Inception’s compatible API setup and JetBrains’s custom-model settings.

Allowance and use elsewhere: The free tokens are a one-time account grant shared across Mercury models. Input and output both count. Use this portable key in compatible editors, scripts, or CLI clients; they all draw from that same grant. When it is exhausted, switch to another service. See Inception’s free-credit and usage details.

3.7 Kilo’s free models through its IntelliJ plugin🔗

1. Open the Kilo Code tool window and sign in with the account from Track G. Complete the browser authorization and return to IntelliJ.

2. Open Settings > Tools > Kilo Code > Models. Set both Default Model and Small Model to Auto Free, then click Apply and OK. This selects free models for chat and background work such as naming sessions.

3. In Kilo’s model picker below the chat, confirm Auto Free (kilo-auto/free). To choose another free model, search for free and select one labeled (free).

4. Send Reply with exactly: Kilo is connected. and confirm the response.

Allowance and use elsewhere: Kilo supplies hosted models with free input and output through its account. The available models and their rate limits can change; use the current free catalog. Kilo’s VS Code extension and CLI can use this access too; changing clients keeps the same account and provider limits. See Kilo’s free-use guide. Keep Kilo on its free hosted models to use this allowance separately from your Inception grant.

3.8 Switch services and carry your task with you🔗

1. When you reach a limit, save your files and stop the current request. Check the provider’s usage/reset display; switch to a different provider while that allowance recovers, or after a one-time grant is exhausted. Do not add billing or create extra accounts or keys to bypass the limit.

2. For Copilot, open its chat panel; for Kilo, open its tool window. For Codex, start a new AI Chat with Codex selected. For Gemini, Groq, or Mercury, use ordinary AI Chat and select the model under your own configured Google or OpenAI-compatible provider. If only one API provider configuration is shown, return to Providers & API keys, select the other provider, restore its key/endpoint if needed, test, apply, and start a new chat.

3. The new service may not have the previous conversation. Give it the task, relevant current code, exact error or test output, what you already tried, and the next step you want. Attach only needed files or selections. Ask the previous tool for a short handoff before its limit, or write the summary yourself.

For example: I’m using Java 11 and the course Tester library. This method should return the number of books. Here is the current method and the failing test output. I already checked the empty-list case. Help me trace the recursive case before suggesting an edit.

Check the provider/agent label before sending so the request uses your intended allowance. Inline completion has its own settings: keep one inline provider enabled as you switch chat services. See JetBrains’s chat and completion settings.

If all available services are limited, continue with the supplied code, IntelliJ’s ordinary editing tools, and course materials until a quota resets.

4.1 Run the supplied environment check🔗

1. Open View > Tool Windows > Terminal, start a new terminal tab, and run:

   java --version

   javac --version

   Both commands must report major version 11. The second command confirms that you selected a full JDK rather than a Java runtime without a compiler.

2. Download ExamplesSetupCheck.java from the link at the top of this page and place it in the project’s blue src directory.

3. Open Run > Edit Configurations. Add an Application configuration named Course Tests.

4. Select Store as project file. In the JRE field, select Project SDK (the JDK 11 configured above), set the main class to tester.Main, and set the program arguments to ExamplesSetupCheck.

5. Apply the configuration and run it. The Tester report must show that one test ran and passed.

If this test does not pass, the problem is in the installation, project JDK, library paths, or run configuration. Do not ask an AI system to rewrite the supplied file; diagnose the configuration, asking course staff for help if needed.

4.2 Compare JetBrains and Copilot completion🔗

Download CompletionComparison.java and place it in src. Its comment describes one line that a completion system might suggest. The correct final program prints exactly Setup complete. The Gemini key configured above supplies models to AI Chat. This activity compares the separately configured JetBrains and Copilot inline completion systems.

4.3 Choose a provisional default🔗

Choose either JetBrains completion or GitHub Copilot completion as your provisional default and leave only that completion system enabled. You may change your choice later. In a short note, record:

• which system you selected,

• whether each system offered a suggestion,

• whether the suggestion produced the required output, and

• one question you still have about IntelliJ or the setup.

Keep this note for your own comparison.

Finally, choose File > New Projects Setup > Save Project as Template, name the template CSAS2123, and confirm that the stored project includes the JDK, language level, libraries, and Course Tests run configuration. Future assignments can begin from this template instead of repeating the setup.

AI tools are fully permitted on all course work. Follow the syllabus for the course collaboration and acknowledgment rules.