Skip to main content
CodinIT connects to GitHub so you can save your code online, work with others, and keep track of changes.

​
What Can You Do?

CodinIT helps you with GitHub in several ways:

Save to GitHub

Save your code online automatically

Start from Templates

Begin projects using pre-made templates

Track Changes

See what changed and when

​
Main Features

  • Automatic saving: CodinIT saves your code to GitHub for you
  • Use templates: Start projects from GitHub templates
  • Auto commits: Your changes are saved automatically
  • Branches: Work on different versions of your code
  • Stay in sync: Keep your local and online code matching
  • Fix conflicts: Help when two people change the same thing
Your Code, Your Control: Your code is always saved in Git, so you can use any Git tool you want.

​
Working with GitHub

​
What You Can Do

CodinIT can do these Git things for you: Basic operations:
  • Copy projects from GitHub
  • Create and switch branches
  • Save and upload changes
  • Fix conflicts when they happen
  • Check what changed
Example commands: 
# Copy a project
git clone https://github.com/user/repo.git

# Make a new branch
git checkout -b feature/new-feature

# Upload your changes
git push origin main

​
Security

How you log in:
  • Personal Access Tokens (a special password)
  • SSH keys (a secure key file)
  • OAuth (log in with GitHub)
  • Permission for specific projects
Staying safe:
  • Commands are checked for safety
  • Limits to prevent abuse
  • Records of what you do
  • Secure password storage

​
Starting from Templates

​
Use Pre-Made Projects

Start quickly with ready-made project templates: Types of templates:
  • Website frameworks (React, Vue, Angular)
  • Backend APIs (Express, FastAPI, NestJS)
  • Complete apps (frontend + backend)
  • Mobile app starters
  • Deployment setups
How to use a template: 
// Start from a template
const template = await fetch('/api/github-template', {
  method: 'POST',
  body: JSON.stringify({
    template: 'facebook/react',
    name: 'my-react-app',
  }),
});

​
Make Your Own Templates

Creating templates:
  • Turn your project into a template
  • Set up variables and settings
  • Add setup scripts
  • Include instructions
Template folder structure: 
template-repo/
├── template.json      # Settings
├── setup.js          # Setup script
├── README.md         # Instructions
└── src/              # Your code

​
Managing Your Projects

​
Creating New Projects

Start a new project: You can create a new GitHub repository right from CodinIT:
  • Choose public (anyone can see) or private (only you can see)
  • Add a description
  • Set up protection rules
  • Add team members
  • Set up automatic testing

​
Bringing in Existing Projects

Import from GitHub: You can bring in projects you already have on GitHub:
  • Paste the GitHub URL
  • Choose which branch to use
  • CodinIT will download it and set it up
After importing:
  • Install needed tools
  • Set up settings
  • Make sure it builds correctly
  • Start the development server

​
Keeping Things in Sync

Automatic syncing: CodinIT keeps your code in sync with GitHub:
  • Saves changes automatically
  • Checks for updates every 30 seconds
  • Helps fix conflicts
  • Watches branch status

​
Common Problems and Solutions

​
Can’t Connect to GitHub

Common problems:
  • Your access token expired
  • You don’t have permission
  • Two-factor authentication issues
  • SSH key problems
How to fix:
  • Make a new GitHub access token
  • Check your repository permissions
  • Use SSH keys for better security
  • Check when your token expires

​
Code Won’t Sync

Common problems:
  • Conflicts when merging
  • Branches went different directions
  • Large files causing issues
  • Internet connection problems
How to fix:
  • Fix conflicts by hand
  • Only force push when you’re sure it’s safe
  • Use Git LFS for big files
  • Check your internet and try again

​
Git is Slow

Common problems:
  • Big projects take forever to download
  • Running out of memory
  • Slow internet
  • Not enough disk space
How to fix:
  • Use shallow clones (download less history)
  • Use Git LFS for binary files
  • Check your internet connection
  • Delete old branches you don’t need

​
Good Habits

​
Organizing Your Code

Branch names:
  • main: The working version
  • develop: Where you combine new features
  • feature/*: New features you’re building
  • hotfix/*: Quick fixes for urgent bugs
  • release/*: Getting ready to release
Commit messages:
  • Write clear messages about what you changed
  • Keep each commit focused on one thing
  • Use a standard format
  • Combine related commits before merging

​
Working with Others

Code review:
  • Make a branch for each change
  • Ask others to review your code
  • Get approval before merging
  • Use automatic tests
Team coordination:
  • Sync branches regularly
  • Know who’s working on what
  • Write down your processes
  • Talk to your team often
Git is Important: Learning Git well will make you a better developer. These skills help you work on any project.
Keep Learning: Git can do a lot more than what’s covered here. Explore features like rebasing and custom hooks as you get more comfortable.

​
Branching and merging

When you create or import a repository in CodinIT, you’ll start on the main branch. This is usually the live version of your project. You can do all your work on main, or create branches. Branches allow you to:
  • Work with others without overwriting each other’s changes.
  • Work on different features separately, so unfinished work doesn’t go live.
    For example, if you’re building three new features on the main branch, you’d have to finish all three before publishing. With branches, you can finish and merge each one into main as they’re ready.

​
Create a new branch in CodinIT

Prerequisite: You must have GitHub connected to CodinIT and a repository already created.
  1. Log in to CodinIT and open a project that is already linked to a GitHub repository.
  2. Click the GitHub icon in the top-right of your screen.
  3. Click Create new branch.
  4. Enter a branch name.
  5. Click Create branch.
You’re now working on your new branch, which is also created in your GitHub repository.

​
Change branches in CodinIT

Prerequisite: You must have GitHub connected to CodinIT, a repository already created, and multiple branches created.
  1. Log in to CodinIT and open a project that is already linked to a GitHub repository.
  2. Click the GitHub icon in the top-right of your screen.
  3. Select the branch you want to switch to.
CodinIT currently doesn’t support merging branches in-app. You need to merge branches in GitHub.

​
Committing and fetching

CodinIT saves your work automatically. Every time you make a change that doesn’t break the project, CodinIT creates a commit for you. It also checks GitHub every 30 seconds for any updates made outside CodinIT and pulls those in.
Very rarely, both CodinIT and GitHub might update at almost the same time. If that happens, CodinIT will keep your changes and overwrite the GitHub version.