'Broken Record' Coding Challenge
First impressions matter in interview coding situations.  My first thought is: There's a lot of code.  And interviewers usually don't like to wade through a lot of code.  For you, as a candidate, that may be a sign that you are taking the wrong approach.

Function names should be lower_case_with_underscores as specified in PEP 8 coding conventions.

There should be a function that accepts a string and returns either True or False.  Your brokenRecord() function…


def brokenRecord(sent):
   if sent == "": # Use defualt string if empty
      sent = "This is a a is This"
   print("Determining if broken record: %s" % sent)
   …
   print("Not a broken record.")



… incorporates all kinds of junk that make it not reusable:


A weird if sent == "": sent = "This is a a is This" special case.  Such 
a special case should be moved out into your testing mechanism — the caller, or, better yet, a doctest.
Printing diagnostics.  Again, such code should be done by the caller.
Not returning any useful value, making it hard for the caller to know what happened.


Catching IndexError to recover from out-of-bounds array access is poor style.

In your main loop, you could eliminate the break by swapping the try and while.

# do until ctrl+c
try:
   while True:
      brokenRecord(raw_input("\nString: "))
except KeyboardInterrupt:
   print("\nThanks for testing!")


Suggested solution

If I, as an interviewer, had asked this question, I would be hoping for a completely different kind of answer.  String analysis is much more easily done using regular expressions.  In particular, you need this feature:


  Backreferences in a pattern allow you to specify that the contents of an earlier capturing group must also be found at the current location in the string. For example, \1 will succeed if the exact contents of group 1 can be found at the current position, and fails otherwise. Remember that Python’s string literals also use a backslash followed by numbers to allow including arbitrary characters in a string, so be sure to use a raw string when incorporating backreferences in a RE.
  
  For example, the following RE detects doubled words in a string.

&gt;&gt;&gt;
&gt;&gt;&gt; p = re.compile(r'(\b\w+)\s+\1')
&gt;&gt;&gt; p.search('Paris in the the spring').group()
'the the'



import re

def is_broken_record(s):
    """
    Check whether a string contains sequential repeated substrings.

    &gt;&gt;&gt; is_broken_record("This is is a broken record")
    True
    &gt;&gt;&gt; is_broken_record("This is a is a broken record")
    True
    &gt;&gt;&gt; is_broken_record("This is a broken record. This is a broken record.")
    True

    &gt;&gt;&gt; is_broken_record("This is not is a broken record")
    False
    &gt;&gt;&gt; is_broken_record("This is a is This")
    False
    &gt;&gt;&gt; is_broken_record("This is a broken record. This is not a broken record.")
    False
    """
    return bool(re.search(r'\b(.+)\s+\1', s))