[Question]
  [
Write a program with length n that outputs another program whose length is the next Fibonacci number after n. The new program must do the same thing - output another program whose length is the next Fibonacci number, etc.  
n itself (the original program's length) does not have to be a Fibonacci number, although it would be nice if it is.
Shortest code wins.
No external resources, ASCII only, free compiler/interpreter required.  
If your output ends in a newline, it is also counted.
  
[Answer]
# Python 2, 160 bytes
```
s='s=%s;c=s;l=len(s%%c)+4;a,b=1,1\nwhile b<l:a,b=b,a+b\nc+="1"*(b-l-1);print s%%`c`;a=1'
c=s
l=len(s%c)+4
a,b=1,1
while b<l:a,b=b,a+b
c+="1"*(b-l-1)
print s%`c`
```
This is a true quasi-quine; it doesn't read its own source, but it generates it. First output (has trailing newline):
```
s='s=%s;c=s;l=len(s%%c)+4;a,b=1,1\nwhile b<l:a,b=b,a+b\nc+="1"*(b-l-1);print s%%`c`;a=111111111111111111111111111111111111111111111111111111111111111111111';c=s;l=len(s%c)+4;a,b=1,1
while b<l:a,b=b,a+b
c+="1"*(b-l-1);print s%`c`;a=1
```
Second:
```
s='s=%s;c=s;l=len(s%%c)+4;a,b=1,1\nwhile b<l:a,b=b,a+b\nc+="1"*(b-l-1);print s%%`c`;a=1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111';c=s;l=len(s%c)+4;a,b=1,1
while b<l:a,b=b,a+b
c+="1"*(b-l-1);print s%`c`;a=111111111111111111111111111111111111111111111111111111111111111111111
```
Edit: Oops. Forgot to change the string when I changed from `;`s to `1`s, so the second output was outputting extra semicolons (which Python doesn't support). Fixed
[Answer]
# CJam, ~~41~~ 31 bytes
```
{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~
```
[Try it online.](http://cjam.aditsu.net/ "CJam interpreter")
### Output
```
$ cjam <(echo '{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~'); echo
{1$+S@]_1=4+1$`,-S*"2$~"}34 21 2$~
$ cjam <(echo '{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~') | wc -c
34
$ cjam <(cjam <(echo '{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~')); echo
{1$+S@]_1=4+1$`,-S*"2$~"}55 34                      2$~
$ cjam <(cjam <(echo '{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~')) | wc -c
55
$ cjam (cjam <(cjam <(echo '{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~'))); echo
bash: syntax error near unexpected token `cjam'
$ cjam <(cjam <(cjam <(echo '{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~'))); echo
{1$+S@]_1=4+1$`,-S*"2$~"}89 55                                                        2$~
$ cjam <(cjam <(cjam <(echo '{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~'))) | wc -c
89
```
### How it works
```
{       "                                                   {…} 21 13                     ";
  1$+   " Duplicate the higher number and add.              {…} 21 34                     ";
  S@    " Push a space and rotate the lower number on top.  {…} 34 ' ' 21                 ";
  ]     " Wrap the stack into an array.                     [ {…} 34 ' ' 21 ]             ";
  _1=   " Push the second element of the array.             [ {…} 34 ' ' 21 ] 34          ";
  4+    " Add 4 to it.                                      [ {…} 34 ' ' 21 ] 38          ";
  1$`,  " Push the length of the stringified array.         [ {…} 34 ' ' 21 ] 38 37       ";
  -S*   " Subtract and push that many spaces.               [ {…} 34 ' ' 21 ] ' '         ";
  "2$~" " Push the string '2$~'.                            [ {…} 34 ' ' 21 ] ' ' '2$~'   ";
}       "                                                   {…}                           ";
21D     " Push 21 and 13.                                   {…} 21 13                     ";
2$~     " Copy the code block an evaluate.                  [ {…} 34 ' ' 21 ] ' ' '2$~'   ";
```
[Answer]
# Python - 89
```
g="%(s,b,a+b);print o.ljust(b-1)";s,a,b="s,a,b=%r,%i,%i;o=s%"+g,89,144;exec("o=s"+g)#####
```
My perfect character count is *gone*. ;\_; Thanks to TheRare for pointing out the newline thing and Quincunx for suggesting I use Python 2, shaving off 2 chars.
**EDIT**: Now just uses more `#`s instead of `1`s; 12 chars shorter.
**EDIT 2**: 94 chars! Eliminated some repetition. >:3
**EDIT 3**: Shorter repr alternative for Python 2.
**EDIT 4**: Output is a character shorter now.
**EDIT 5**: The use of `%r` to shorten it was taken from an answer on another question by @primo.
**EDIT 6**: Shorter. :D
Here's a Python 3 version:
```
g="%(s,b,a+b);print(o.ljust(b-1))";s,a,b="s,a,b=%r,%i,%i;o=s%"+g,89,144;exec("o=s"+g)####
```
This answer is similar to the one by @Quincunx.
[Answer]
# CJam, 26 23
I just had a try with your language.
```
7{9\@5mq)2/*')*\"_~"}_~
```
9 is `(22*0.618 + 0.5 - 1)/1.618 + 1`.
It computes its own length`*1.618` instead of repeatedly adding the two numbers. In the first version, it will fill the output before `{` like `1)))))))))`, which counts those characters themselves. Say the result `n`. The total length is `n+22`, and the new length before `{` should be `(n+22)*1.618-22`, rounded. Decrease it by one to count the number of `)`'s. Then it will be approximately equal to `(n+8)*1.618`.
Older version:
```
-3{1\@5mq)2/*E+')*\"_~"}_~
```
The number 14 is `24*0.618 + 0.5 - 1`.
[Answer]
# JavaScript, 94
```
(function q(w,e){return ('('+q+')('+e+','+(s=w+e)+')'+Array(s).join('/')).substr(0,s)})(55,89)
```
Based on a well-known [JavaScript Quine](http://www.nyx.net/~gthompso/self_javas.txt), this returns almost the same function, only followed by amount of slashes, such that it sums up to 144 which is the next Fibonacci number after N. And so on...
N is not a Fibonacci number, but it was only "nice to have".
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 65 bytes
```
a,b=55,89;exec(s:="print((f'a,b={b,a+b};exec(s:=%r)#'%s*b)[:b])")
```
[Try it online!](https://tio.run/##RY7BCoMwEETv@YolRUza5CBFsCl@iXhINGkDEiXxUBG/3Rot9rQ7O8ubGabx3bt7Mfi16VtdYoxXyVSZ56x4PPVHNySIEg/eupEQk0ZvVkze1HK6iaeXNAlXRSuhaorpulGqTPCsRqjVBlobhk5OJFCBAA6WSTnnBOZOu@2@AN1kSk87xPXV9Up2EIttKg4oISBkeg8WrAMv3UuTfMfubeIPm4@6WPxylz@Wrl8 "Python 3.8 (pre-release) – Try It Online")
[Answer]
# [Pari/GP](http://pari.math.u-bordeaux.fr/), 63 bytes
```
(f(a,b)=print1(s=Str("(f="f")("b","a+b");")10^(b-#s-1)))(55,89)
```
[Try it online!](https://tio.run/##BcFBCoAgFATQu0ybGVLIhVCEp2gf@BeGmxDt/vZey736p83JwuxMqfX6foEjXV8nWBIKRBgc8mrQCYXtpvll@CCJMbr90Jw/ "Pari/GP – Try It Online")
[Answer]
## Mathematica
```
({0};
 With[{n = Ceiling[ InverseFunction[Fibonacci]@LeafCount@#0 ], l = Length[#0[[1, 1]]]},
    #0 /. {0..} -> ConstantArray[0, Fibonacci[n+1] - LeafCount[#0] + l]
 ]) &
```
This is a very straightforward implementation (i.e. no obfuscation here). It is an anonymous function that returns itself with a bit of padding to achieve the correct length. Mathematica is homoiconic: code and data are both represented as Mathematica expressions, which makes it realtively easy to modify/generate code on the fly. This also means that character counts are not a natural measure of code length. Epxression size (["leaf count"](http://reference.wolfram.com/language/ref/LeafCount.html)) is. This version is based on leaf counts as code length measure.
If we assign this anonymous function to a variable `f` (so I can show what happens in a readable manner), and keep calling it 1, 2, 3, ... times, each time measuring the length of the return value, this is what we get:
```
In[]:= f // LeafCount
Out[]= 42
In[]:= f[] // LeafCount
Out[]= 89
In[]:= f[][] // LeafCount
Out[]= 144
In[]:= f[][][] // LeafCount
Out[]= 233
```
Regarding the free interpreter requirement: Mathematica is free for the Raspberry Pi. Otherwise this code should be straightforward to port to [Mathics (open source)](http://www.mathics.net/). The only thing missing from Mathics is `InverseFunction`, which can be replaced as [here](https://stackoverflow.com/a/5162856/695132) (but I'm lazy :).
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 78 bytes
```
p,c=55,89;exec(s:="print((a:=f'p,c={c},{p+c};exec(s:=%r)'%s)+'#'*(c-len(a)))")
```
[Try it online!](https://tio.run/##K6gsycjPM7YoKPr/v0An2dbUVMfC0jq1IjVZo9jKVqmgKDOvREMj0co2TR0kXZ1cq1NdoJ1cC1eiWqSprlqsqa2urK6lkaybk5qnkaipqamk@f8/AA "Python 3.8 (pre-release) – Try It Online")
---
# [Python 2](https://docs.python.org/2/), 79 bytes
```
p,c,s=55,89,"a='p,c,s=%d,%d,%r;exec s'%(c,p+c,s);print a+'#'*(c-len(a))";exec s
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v0AnWafY1tRUx8JSRynRVh3CV03RAaEi69SK1GSFYnVVjWSdAm2gjKZ1QVFmXolCora6srqWRrJuTmqeRqKmphJU5f//AA "Python 2 – Try It Online")
]