The situation is this. You have a server, which is not initialized as bare repository. You have a local machine, with its own working copy of the code/ project. This is the most common case actually.
Naming convention: server, client are the two systems we are looking at. server is the remote system. client is the local machine or laptop.
In order to setup proper git repository and to push/pull easily, follow the steps:

server# aptitude install git-core git-doc
client# aptitude install git-core git-doc

Now, we create the Git repository at the server and get it at the client side.

server$ mkdir ~/repo_home
server$ cd ~/repo_home
server$ git init

Initialized empty Git repository in /home/server/repo_home/.git/

server$ git commit --allow-empty -m initial

Created initial commit 999755e: initial

server$ git branch incoming
server$ git branch

incoming
* master

client$ mkdir ~/repo_local
client$ cd ~/repo_local
client$ git clone master@remotehost:/path_to_repo/repo_home

Initialized empty Git repository in /home/laptop/repo_local/.git/

This is the basic setup, now we can add files and try pushing and pulling from remote repositories

1. from server to client:

There is no change to be made at the server side. Whenever you add a new file at the server, then you should commit and push.

server$ git rm foo.txt
server$ git commit

# On branch master
# Your branch is ahead of 'origin/master' by 2 commits.
#
# Changed but not updated:
# (use "git add/rm ..." to update what will be committed)
# (use "git checkout -- ..." to discard changes in working directory)
#
# deleted: foo.txt
#

server$ git push . incoming

Everything up-to-date

But it is highly unlikely
At the client side, you have to just clone and get the data. For later, (if by chance you update the server.. again highly unlikely) you can use pull to simple get it there.

client$git pull

master@ipaddress's password:
remote: Counting objects: 37, done.
remote: Compressing objects: 100% (20/20), done.
remote: Total 21 (delta 12), reused 0 (delta 0)
Unpacking objects: 100% (21/21), done.
From master@ipaddress:/path_to_repo/repo_home
372f834..e4aea6c master -> origin/master
Updating b562c9b..e4aea6c
Fast forward
Auto packing your repository for optimum performance. You may also
run "git gc" manually. See "git help gc" for more information.
Counting objects: 21278, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (21092/21092), done.
Writing objects: 100% (21278/21278), done.
Total 21278 (delta 2261), reused 0 (delta 0)
foo.txt | 1-
1 files changed, 0 insertions(+), 1 deletions(-)
delete mode 100644 foo.txt

As simple as that!

2. From client to server:

client$ git config remote.origin.push master:incoming
client$ git add foo.txt
client$ git commit -m hello

Created commit 2297bcf: hello
1 files changed, 1 insertions(+), 0 deletions(-)
create mode 100644 foo.txt

client$ git commit

# On branch master
# Your branch is ahead of 'origin/master' by 2 commits.
#
# Untracked files:
# (use "git add ..." to include in what will be committed)
#
# foo.txt

client$ git push
master@ipaddress's password:

Counting objects: 36, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (33/33), done.
Writing objects: 100% (35/35), 40.49 KiB, done.
Total 35 (delta 14), reused 0 (delta 0)
To master@ipaddress:/path_to_repo/repo_home
b89b4db..3105ea5 master -> incoming

Thats it at the client side. Now at the server side..

server$ cd ~/repo_home
server$ git pull . incoming

From .
* branch incoming -> FETCH_HEAD
Merge made by recursive.
foo.txt | 1 +
1 files changed, 1 insertions(+), 0 deletions(-)


For more help, check Help.GitHub.Com