Do our genomes look designed? Let's address this point, hoisted from the comments of this post:

Actually, shared genetics between chimps and humans is agnostic with respect to evolution or "intelligent design". In software engineering, you often find shared code (or even junk code) in the source of various projects as it develops from "Product 1.0" to "Product 2.0" to "Product 3.0". I.e., it's a strawman argument to assume the "intelligent designer" started from scratch for chimps and humans. That doesn't sound intelligent at all.

Like a software designer, the "designer" would have hacked up whatever existing code base he had to
get him to the next milestone. So the "chimp release" and "human release" of the designer's software
of course share the same bugs, since they are off the same code base.

Note this is not a claim that the designer "just made things look that way" i.e. tried to trick observers;it's based on how things are actually done in software design were there is no intent to trick at all. It's simple basic engineering for large projects--you don't start from scratch each time.

To answer this, we need to get into details. It's easy to make analogies between biology and engineering that look ok superficially, but we need to keep the details in mind - as Richard Feynman put it, "[our] thoughts [in science] are restricted in a straitjacket, so to speak, limited by the conditions that come from our knowledge of the way nature really is."

So let's imagine that all species on earth were made by an amazingly powerful (and long-lived) genetic software engineer. This engineer, as our commenter points out, would be able to reuse a lot of code. In fact, the amount of reusable code is mind-boggling, because most of the basic cellular functions are carried out by essentially the same genetic machinery in all life. Transcription, translation, glycolysis, DNA replication, etc. - so many of the basic processes of the cell are essentially the same in all species.

This reuse of code is fortunate for me, because all of my research is based on the premise that what I learn about a basic process (cell division) in one species (yeast), will help us to understand that same basic process in humans. And in fact this premise has been incredibly successful - much of what we know about cell division in humans was first worked out in yeast.

One can then imagine our intelligent software engineer reusing lots and lots of code - humans and chimps are similar, so they need only a few tweaks in the software to make them different (maybe one line of code out of 100), humans and chickens will have more differences, etc. On this principle, you end up with a pattern of similarities and differences - humans most closely resemble chimps and gorillas, the chicken genome is more similar to the genomes of other birds, etc. And let's not forget mistakes - our designer might be imperfect, and a copying error or design flaw that crops up when programming the chimp genome will also crop up in the human genome when the designer reuses large swaths of chimp code.

Convergent Evolution

But if we look at the details, the software analogy breaks down. One point where the software analogy fails is convergent evolution: places where the designer arbitrarily decides not to reuse code to achieve a given function, and instead uses code written for a completely different purpose. A well-known example is the whale flipper - instead of reusing code that functions just fine to make shark fins, our software designer has taken the code for tetrapod wrists and digits, and awkwardly tweaked that to to make whale flippers.

This kind of thing, (which biologists call convergent evolution) is common throughout nature. And it's not just something that happens on the morphological level - it happens on the molecular level as well. Convergent evolution at the molecular level is everywhere - venom in reptiles, special metabolic enzymes in flight muscle in bats and hummingbirds, color vision in lemurs and humans - there are literally hundreds examples.

In many of these cases, it is very easy to show (especially in cases of molecular convergent evolution) that there is absolutely no functional reason to not reuse code. But for some inscrutable reason, the designer made things difficult and, instead of using similar code for similar functions, took code for a completely different function and rewrote it. Human software engineers do some strange things, but they don't take CD burning software and rewrite it into a word processor.

Non-synonymous Mutations

Another place where the software analogy breaks down: the pattern of mutations in we find in homologous genes (homologous here means the same gene, but in different species). This would be another instance of arbitrarily changing code for no functional reason. Let's take the example of your basic sugar metabolizing enzymes, those involved in glycolysis. These enzymes basically do the same things in all organisms; their function hasn't changed in at least a billion years. And yet there are differences between species in these enzymes - glucose phosphate isomerase in chicken is not the same as glucose phosphate isomerase in humans, even though this particular enzyme carries out the same chemical reaction in all species. More importantly, there are species differences of no functional consequence, called non-synonymous mutations, mutations in the gene that don't change the amino acid sequence of the protein.

The pattern of non-synonymous changes, amazingly, is just what we'd expect if what was going on was the accumulation of mutations over the course of evolution, with today's species being part of one big family tree. There is no reason that kind of pattern would occur under a software design model, unless of course the designer created designs in an evolutionary pattern. That is, before sitting down to write the chicken genome, the designer created some 'common bird ancestor' software, with arbitrary changes of no functional consequence, and then used that software as the framework for writing the genomes of today's living birds. (And I'm oversimplifying here - to really get the pattern right, you would have to hypothesize a series of common ancestor software packages - one for each major taxon in the bird line.) In other words, this designer would not have first written the quail genome, and then tweaked that to make a chicken genome, and then tweaked that to make the turkey genome, etc. - that's not the pattern we see in nature.

A Designer can Explain Anything

Of course, you can hypothesize that our intelligent designer started out with an original cell genome, then tweaked that into making a variety of (now long-extinct) bacterial genomes, and then tweaked those into making an 'original eukaryote genome', etc. That's the beauty of making up an intelligent designer without any operational constraints - it can explain anything. We can come up with some version of an intelligent designer that can explain any pattern in nature (and I've left out a lot of bizarre patterns in nature that we'd have to explain). But the point is that such a designer is not operating by human design principles - that designer most decidedly does not do things the way human software engineers do things.

That's what we're left with in the end. A pattern in nature that is just what we expect evolution to produce, and not what we expect a human-like designer to produce. If you want to hypothesize some other designer, you have to explain why that designer made things (intentionally or unintentionally) look like they evolved - because human design principles don't explain the evolutionary pattern.